Architecture Paradigm Layered

---
name: architecture-paradigm-layered
description: '- When to Employ This Paradigm'
---

---
name: architecture-paradigm-layered
description: |

Triggers: monolith, separation-of-concerns, n-tier, architecture, layered
  Use a Layered (N-Tier) architecture to separate presentation, domain logic, and
  data access responsibilities within a system.

  Triggers: layered architecture, n-tier, separation of concerns, presentation layer,
  data access layer, service layer, traditional architecture, monolith structure,
  layer enforcement, dependency direction

  Use when: building traditional applications with clear boundaries, working with
  moderate-sized teams, needing familiar and well-understood patterns, compliance
  requirements demand clear separation

  DO NOT use when: selecting from multiple paradigms - use architecture-paradigms first.
  DO NOT use when: high scalability needs independent component scaling.
  DO NOT use when: teams need independent deployment cycles - use microservices.

  Consult this skill when implementing layered patterns or enforcing layer boundaries.
version: 1.3.5
category: architectural-pattern
tags: [architecture, layered, n-tier, separation-of-concerns, monolith]
dependencies: []
tools: [dependency-validator, layer-enforcer, architecture-compliance-checker]
usage_patterns:
  - paradigm-implementation
  - legacy-system-modernization
  - team-structure-alignment
  - compliance-requirements
complexity: low
estimated_tokens: 700
---
## Table of Contents

- [When to Employ This Paradigm](#when-to-employ-this-paradigm)
- [When NOT to Use This Paradigm](#when-not-to-use-this-paradigm)
- [Adoption Steps](#adoption-steps)
- [Key Deliverables](#key-deliverables)
- [Technology Guidance](#technology-guidance)
- [Risks & Mitigations](#risks-mitigations)
- [Troubleshooting](#troubleshooting)

# The Layered (N-Tier) Architecture Paradigm

## When to Employ This Paradigm
- When teams need clear architectural boundaries and a familiar structure for moderate-sized systems.
- When compliance or operations teams require clear separation of concerns (e.g., UI vs. domain logic vs. persistence).
- When the deployment artifact remains a monolith, but code clarity and separation are degrading.

## When NOT to Use This Paradigm
- When high scalability demands require independent scaling of components
- When multiple teams need independent deployment cycles
- When complex business logic requires frequent cross-layer communication
- When microservices architecture is already planned or in place
- When real-time processing requirements make layered communication too slow

## Adoption Steps
1. **Define the Layers**: Establish a clear set of layers. A common stack includes: Presentation -> Application/Service -> Domain -> Data Access.
2. **Enforce Dependency Direction**: Code in a given layer may only depend on the layer immediately below it. Forbid any "upward" dependencies or imports.
3. **Centralize Cross-Cutting Concerns**: Implement concerns like logging, authentication, and validation as centralized middleware or policies, rather than duplicating this logic in each layer.
4. **Test Each Layer Appropriately**: Apply testing strategies suitable for each layer, such as unit tests for the domain layer, service-layer tests for orchestration logic, and integration tests for persistence adapters.
5. **Document and Enforce Interactions**: Maintain up-to-date dependency diagrams and use automated architecture tests to prevent developers from creating "shortcut" dependencies that violate the layering rules.

## Key Deliverables
- An Architecture Decision Record (ADR) that captures the responsibilities of each layer, the allowed dependencies between them, and the policy for any exceptions.
- A formal dependency diagram stored with the project documentation.
- Automated architectural checks (e.g., using ArchUnit, dep-cruise, or custom scripts) to prevent rule violations from being merged.

## Technology Guidance

**Layer Implementation Patterns**:
- **Presentation Layer**: React/Vue/Angular (Frontend), MVC Controllers (Backend)
- **Application Layer**: Service classes, Application services, Use case orchestrators
- **Domain Layer**: Business entities, Domain services, Business rules validation
- **Data Access Layer**: Repository pattern, ORM mappers, Data access objects (DAO)

**Architecture Enforcement Tools**:
- **Java**: ArchUnit for dependency rule testing
- **JavaScript/TypeScript**: ESLint rules with dependency tracking
- **C#**: NDepend for architectural analysis
- **Python**: Custom decorators and import analysis tools

**Common Layer Stacks**:
- **3-Layer**: Presentation → Business Logic → Data Access
- **4-Layer**: Presentation → Application → Domain → Infrastructure
- **5-Layer**: UI → Controller → Service → Domain → Persistence

## Real-World Examples

**Enterprise ERP Systems**: SAP and Oracle ERP use layered architecture to separate user interfaces from business logic and database operations, enabling different frontend applications to share the same business rules.

**Banking Applications**: Financial institutions employ layered architecture to maintain strict separation between customer-facing interfaces, transaction processing, and secure data storage for regulatory compliance.

**E-commerce Platforms**: Traditional e-commerce sites use layered architecture to separate product catalogs, shopping cart logic, order processing, and payment handling into distinct layers.

## Risks & Mitigations
- **Excessive Rigidity and Latency**:
  - **Mitigation**: For features that span multiple layers, strict adherence can lead to excessive "pass-through" code and increased latency. In such cases, consider using a Façade pattern to provide a more direct interface where appropriate.
- **"Leaky" Layers**:
  - **Mitigation**: Developers may be tempted to bypass architectural rules for expediency, which degrades the architecture. Treat all architectural violations as build-breaking failures or critical issues in code review.
## Troubleshooting

### Common Issues

**Command not found**
Ensure all dependencies are installed and in PATH

**Permission errors**
Check file permissions and run with appropriate privileges

**Unexpected behavior**
Enable verbose logging with `--verbose` flag