liveBook · Manning

Microservice architecture

As explained in Acing the Frontend Interview

A microservice is an independently deployable service that implements a focused business or technical capability within a distributed application.

Microservice architecture composes an application from small, independent services. Each service is self-contained, focuses on a specific business capability, and typically manages its own data store. section 6.1

Use microservices when the system and organization benefit from independent service boundaries:

  • Independent deployment lets teams evolve services separately and supports team autonomy. section 6.1
  • Horizontal scaling can target individual services rather than requiring the entire application to scale together. section 6.1
  • The trade-off is operational complexity: microservices require orchestration, monitoring, and distributed-systems expertise. section 6.1
  • Compared with monolithic, 3-tier, and n-tier architectures, microservices are inherently distributed and more highly decoupled. section 6.1

Interview trade-off

For a large SaaS platform or high-scale distributed system, microservices can provide team autonomy, independent deployment, and horizontal scaling. A strong explanation should also acknowledge the added need for orchestration, monitoring, and distributed-systems expertise. section 6.1

Table 6.1 Architectural paradigms
Topic
Fundamentals
Applied skills
Advanced
Monolithic architectures
Understand single-deployable unit with tightly coupled components. Know pros: simplicity, ease of testing.
Break down feature modules using a Model-View-Controller (MVC)–style layered structure (controllers, services, database). Refactor legacy code safely.
Design strategies for modularity (e.g., using Hexagonal or Onion Architecture).
Plan gradual extraction to services.
3-tier architectures
Know layers: Presentation (UI), Application (logic), Data (DB).
Understand separation of concerns.
Connect frontend to backend via REST/GraphQL. Build APIs that link DB and UI layers.
Analyze scaling strategies per tier (e.g., CDN for frontend, caching for backend). Secure each tier independently.
N-tier Architectures
Understand how multiple layers (UI, CDN, caching, or authentication, Business Logic, DB) improve modularity and scalability.
Implement separation of concerns through middle tiers. Add services (e.g., auth, caching).
Optimize inter-tier communication, reduce latency, and apply security/logging consistently.
Microservices
Understand service decomposition, bounded context, and inter-service communication (REST, events). See chapter 7 for details.
Design, build, and deploy multiple small services. Implement discovery, retries, and health checks.
Handle distributed data consistency (e.g., saga pattern). Optimize service orchestration and observability.

Compare microservices with monolithic, 3-tier, and n-tier architectures across fundamentals, applied skills, and advanced design concerns. section 6.1

How Acing the Frontend Interview covers it

How deep it goes
Defines service boundaries and trade-offs, but stops short of detailed orchestration, communication, or data-management implementation.
Examples
Uses architectural comparison tables and identifies large SaaS platforms and high-scale distributed systems as use cases.
What it assumes
Assumes familiarity with application architecture and builds toward distributed-systems reasoning for frontend and full-stack collaboration.
What you can do after
Evaluate microservices against monolithic and layered architectures using deployment, scaling, autonomy, and operational-complexity trade-offs.
How it connects
Connects microservices with monolithic architectures, layered architectures, horizontal scaling, orchestration, monitoring, and distributed systems.

Also explained in

Compare how 18 books explain microservice architecture →

Related concepts

This explainer was generated by Manning's knowledge graph from the text of Acing the Frontend Interview. The section links point to the parts of the book it draws on.