Layered Architecture – MVC, n-Tier & Separation of Concerns

This article is a glossary entry covering layered architecture models – including exam questions and tags.

In a Nutshell

Layered architecture divides software into logically distinct tiers. Common examples include MVC and n-tier patterns, which promote modularity, maintainability, and testability.

Core Definition

Layered architecture organizes applications into clearly defined horizontal layers, each with specific responsibilities. The n-tier model (typically 3-tier) consists of at least three layers: presentation, business logic, and data access. MVC (Model-View-Controller) is a widely adopted architectural pattern that separates the user interface (View), business logic (Controller), and data models (Model). This structure encourages code reuse, parallel development, and isolated testing of components. Data flows in a controlled manner through the layers, preventing unwanted dependencies.

Key Points for Exams

• Separation of presentation, logic, and data access
• MVC = View, Controller, Model (user-centric)
• n-Tier = logical architecture with 2–n layers
• Enforces clean separation of concerns (exam-relevant)
• Improves testability and component interchangeability
• Reduces attack surface through well-defined interfaces
• Lowers long-term maintenance costs with clean structure
• Architecture must be documented and traceable in project plans

Core Components

1. Presentation layer (UI)
2. Logic or controller layer
3. Data layer / Repository
4. Model classes (MVC)
5. Interfaces for communication
6. Validation and error handling
7. Frameworks and middleware
8. Service layer (e.g., REST API)
9. Authentication and authorization
10. Unit testing per layer

Practical Example

// Example: MVC with JavaScript
- Model: "Product" class with attributes name, price
- View: HTML template with placeholders
- Controller: JS function handles "add to cart" click

Explanation: The controller mediates between user (View) and data model (Model) – data flow is clearly separated.

Advantages and Disadvantages

Advantages

• Clearly structured codebase
• Better testability through loose coupling
• Reusable modules
• Team collaboration enabled by parallel development

Disadvantages

• Overhead for small projects
• Higher initial planning effort
• Potential added complexity from layer separation

Common Exam Questions (with Brief Answers)

1. Purpose of a layered architecture? Clear separation of concerns and improved maintainability.
2. Three layers of the classic n-tier model? Presentation, business logic, data access.
3. Role of the controller in MVC? Mediates between View and Model – processes user interactions.
4. How does MVC improve testability? Individual components (e.g., Model) can be tested in isolation.
5. What is loose coupling in layered architecture? Each layer knows only the directly adjacent layer, not the entire application.
6. How does layered architecture protect against security issues? Controlled data flow prevents direct access to sensitive data.
7. Purpose of interfaces between layers? Enable modular communication and facilitate future changes.
8. When is a layered architecture overkill? For very small, linear projects with straightforward logic.

Key Resources

1. https://learn.microsoft.com/en-us/aspnet/mvc/overview/overview
2. https://www.ibm.com/docs/en/i/7.5?topic=overview-n-tier-architecture
3. https://www.baeldung.com/spring-service-layer
4. https://8thlight.com/blog/uncle-bob/2012/08/13/the-clean-architecture.html
5. https://angular.io/guide/architecture