N-tier architecture

N-tier (multi-tier) architecture divides an application into separate logical layers (tiers), each with one responsibility, that communicate only with adjacent layers. Tiers can run on the same machine or on different servers.

Presentation tier   (browser, React/HTML UI)
        |
Application / Business-logic tier   (Node.js, Java, PHP server)
        |
Data-access tier    (ORM, DAO, API)
        |
Data tier           (MySQL, MongoDB)

Common forms: 2-tier (client + database), 3-tier (presentation, logic, data), and larger N-tier with extra layers such as caching, API gateway, and messaging.

Tiers explained

1. Presentation: displays data and captures user input.
2. Business logic: rules, validation, processing, authentication.
3. Data access / data: stores and retrieves persistent data.

Benefits

• Separation of concerns: each layer has a clear role.
• Independent development: teams work on UI, logic, and data separately.
• Reusability: the same business logic serves web, mobile, and other clients.
• Security: the database is not exposed directly to clients; only the logic tier reaches it.
• Flexibility: technology in one tier (e.g. the database) can be swapped with little effect on others.
• Easier testing: each tier can be tested in isolation.

How it improves scalability

• Each tier can be scaled independently: add more app servers behind a load balancer when traffic rises, or add database replicas for reads.
• Resource-heavy tiers can be placed on stronger machines.
• Caching and message queues between tiers absorb load spikes.
• Stateless application tiers make horizontal scaling straightforward.

How it improves maintainability

• A change in one tier (e.g. redesigning the UI) does not force changes in others.
• Bugs are easier to locate because responsibilities are isolated.
• Loose coupling through defined interfaces (REST APIs) allows components to be upgraded or replaced.
• Consistent structure makes the code easier to understand and extend.

Trade-offs: more components mean added complexity, network latency between tiers, and more deployment effort.