N-tier architecture
N-tier architecture organizes an application into distinct tiers with separate responsibilities and defined interactions, which may be logical divisions or separately deployed components.
Functional Design and Architecture: Examples in Haskell
Layering is an organizational pattern that arranges software components into levels with constrained dependencies between levels.
- How it is used
- Organizes application responsibilities and controls dependencies between business logic, interfaces, and implementations.
- How deep it goes
- Defines layers and responsibilities, then develops sublayers, dependency checks, interface boundaries, and concrete integration examples.
- Examples
- Uses a stateful sandwich application, a typed key–value database layer, and a layered web service.
- What you can do after
- Evaluate application boundaries and dependencies, and identify opportunities to separate logic from infrastructure for testing.
Read how Functional Design and Architecture: Examples in Haskell explains n-tier architecture →
Building Web APIs with ASP.NET Core
A layered system organizes communication through intermediary components that hide or mediate the services behind them.
- How it is used
- Uses intermediary services to improve a RESTful web API’s security, performance, and scalability.
- How deep it goes
- Explains component roles and expected benefits, but defers implementation until production deployment.
- Examples
- Illustrates the pattern with a board-game API, its DBMS, and proposed reverse-proxy and CDN layers.
- What you can do after
- Evaluate/understand it by identifying what each intermediary contributes before planning a production deployment.
Read how Building Web APIs with ASP.NET Core explains n-tier architecture →
Acing the Frontend Interview
N-tier architecture extends layered application structure with multiple specialized tiers that may run on separate infrastructure.
- How it is used
- Frames system-design decisions around separating presentation, logic, data, and specialized cross-cutting services.
- How deep it goes
- Explains tier boundaries, trade-offs, deployment conditions, and CORS concerns, but stops short of detailed distributed-systems internals.
- Examples
- Uses presentation, business-logic, data, CDN, caching, and authentication tiers plus Express CORS and Vite proxy configurations.
- What you can do after
- Evaluate architectural choices and explain scaling, separation, network boundaries, CORS, and operational trade-offs in interviews.
Read how Acing the Frontend Interview explains n-tier architecture →
Go by Example
A layered package structure is an organization in which packages depend only on packages in lower layers of the structure.
- How it is used
- Organizes Go packages so higher-level services build on foundational packages without reverse imports.
- How deep it goes
- Defines one-way dependency direction and illustrates core service, REST API, and command packages; defers remaining implementations.
- Examples
- Uses io, net, and http, plus link, link/rest, and linkd packages.
- What you can do after
- Apply it to arrange core logic, REST delivery, and commands while avoiding import cycles.
BDD in Action, Second Edition
Layered architecture is a software architecture pattern that organizes responsibilities into layers with controlled dependencies between them.
- How it is used
- Uses separated layers to design scalable test automation and protect existing functionality while teams introduce improvements.
- How deep it goes
- Defines three test-automation layers and their responsibilities, then stops short of specifying complete implementation details.
- Examples
- Uses an existing airline system, journey maps, high-value workflows, and Specification, Domain, and Integration layer examples.
- What you can do after
- Design scalable test automation by separating business specifications, domain activities, and technology-specific integrations.
Read how BDD in Action, Second Edition explains n-tier architecture →
Java Persistence with Spring Data and Hibernate epub
A layered architecture organizes an application into separate layers with distinct responsibilities and controlled dependencies.
- How it is used
- Organizes persistence, presentation, workflow, and business logic behind controlled interfaces.
- How deep it goes
- Defines three layers, dependency direction, and cross-cutting concerns, but stops short of concrete implementation configuration.
- Examples
- Uses an online auction application, browser interaction, persistent Java classes, and a persistence-layer architecture figure.
- What you can do after
- Evaluate application structure by assigning concerns to layers and checking dependencies against adjacent-layer interfaces.
Read how Java Persistence with Spring Data and Hibernate epub explains n-tier architecture →
Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
A three-tier application is an application architecture that separates presentation, application, and data responsibilities into distinct tiers.
- How it is used
- Organizes Terraform infrastructure for a complete application whose presentation, application, and data responsibilities need separate deployment boundaries.
- How deep it goes
- Explains module composition, network placement, routing, security, and environment variation, but does not provide provider-specific resource configurations.
- Examples
- Uses a CDN, load balancer, API container, database, cache, public and private subnets, NAT, and environment-sized databases.
- What you can do after
- Build it from scratch by composing Terraform modules, wiring their inputs and outputs, and placing services across public and private networks.
Practices of the Python Pro
A multitier architecture organizes an application into separate layers or tiers with distinct responsibilities that can evolve independently.
- How it is used
- Organizes presentation, business logic, and persistence so each concern can evolve independently.
- How deep it goes
- Explains responsibilities, module boundaries, reuse, and team specialization without detailing implementation internals.
- Examples
- Uses Bark’s command-line interface, database, Python modules, CRUD operations, and GitHub-star import feature.
- What you can do after
- Builds applications with separate presentation, business-logic, and persistence layers that support later extension.
Read how Practices of the Python Pro explains n-tier architecture →
Also covered in
- Grokking Simplicity
- Acing the CCNA Exam: Volume 2 Advanced Networking and Security
- Think Distributed Systems
- Natural Language Processing in Action, Second Edition
- The Cloud at Your Service: The when, how, and why of enterprise cloud computing
- F# in Action: A Revised Edition of Get Programming with F#
- Fundamentals of CybersecurityIn early access (MEAP)
- Google Anthos in Action
- Grokking Concurrency
- The Design of Web APIs, Second Edition
- AI-Powered Developer: Build software with ChatGPT and Copilot
- Kafka for Architects
What to know first
- business logicBusiness logic is the domain-specific rules, computations, and decisions that determine how a software system processes operations and behaves.
- HTTPHTTP is an application-layer protocol that defines request-and-response communication for transferring resource representations and related metadata between networked systems.
- load balancingLoad balancing is the distribution or adjustment of work across multiple resources to manage demand and reduce overload or imbalance.
- contractA contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
Related concepts
- stratified designused by · An architectural pattern that organizes software into layers ordered from relatively stable foundations to more frequently changing elements.
- data layerhas part · A software architectural layer that mediates access to data by storing, retrieving, transforming, or exposing it to other components.
- frontend developmenthas part · Frontend development is the practice of building the user-facing, client-side interface and behavior through which people interact with software.
- business logichas part · Business logic is the domain-specific rules, computations, and decisions that determine how a software system processes operations and behaves.
- domain layerhas part · A domain layer is the architectural part of an application that contains its domain concepts, business rules, and behavior, distinct from infrastructure and delivery concerns.
- web applicationincludes · A web application is software that provides functionality through web technologies and is accessed over a network, typically through a browser or other web client.
Questions about n-tier architecture
What is n-tier architecture?
N-tier architecture organizes an application into distinct tiers with separate responsibilities and defined interactions, which may be logical divisions or separately deployed components.
Which Manning books explain n-tier architecture?
Functional Design and Architecture: Examples in Haskell, Building Web APIs with ASP.NET Core, Acing the Frontend Interview, Go by Example, BDD in Action, Second Edition, Java Persistence with Spring Data and Hibernate epub, Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu and Practices of the Python Pro.
What should I know before learning n-tier architecture?
Manning books that teach n-tier architecture usually introduce business logic, HTTP, load balancing and contract first.
What kinds of n-tier architecture are there?
Kinds of n-tier architecture include web application.
What are the parts of n-tier architecture?
N-tier architecture includes data layer, frontend development, business logic and domain layer.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.







