25.4. Layered Architecture
Table of Contents
Why Layered Architecture Exists
When an application is small, it is tempting to put everything in a few files. For example, you might:
- Read HTTP requests.
- Query the database.
- Apply business rules.
- Format responses.
all in one big function.
This becomes very hard to maintain as the code grows. Layered architecture solves this by separating responsibilities into layers. Each layer focuses on one kind of work and talks only to the layers around it.
A layered backend is easier to:
- Understand, because similar code lives together.
- Test, because you can test each layer in isolation.
- Change, because you can replace or rewrite one layer without rewriting everything.
In this chapter, you will see what the common layers are and how they interact in a backend application.
Important rule
In a layered architecture, higher layers must not "reach around" and talk to lower layers that are not directly below them. Always go through the next lower layer.
Common Layers in Backend Applications
Most backend applications use a variation of these layers:
| Layer | Main responsibility | Talks to |
|---|---|---|
| Presentation | Handle HTTP, map requests to operations | Service / Application |
| Service | Business rules, use cases, workflows | Repositories, other services |
| Data Access | Interact with database or external storage | Database / external systems |
| Infrastructure | Technical utilities such as email, queues, cache | External services |
You might see different names:
- Presentation layer might be called API layer, web layer, or controller layer.
- Service layer might be called business layer, domain layer, or application layer.
- Data access layer might be called repository layer, persistence layer, or ORM layer.
The idea is the same. Each layer answers a different question:
- Presentation: "How do we talk to the client?"
- Service: "What should happen for this request?"
- Data access: "How do we fetch or save data?"
A Typical Request Flow Through Layers
Imagine a simple "create task" endpoint in a task management API.
A typical flow looks like this:
- Presentation layer (controller / FastAPI route)
- Accepts the HTTP POST
/tasksrequest. - Validates and parses the request body.
- Calls a service method such as
create_task. - Service layer
- Applies business rules such as "title must be unique per user".
- Uses repositories to check existing tasks and create a new task.
- Returns a domain object, such as a
Taskentity. - Data access layer (repository)
- Converts the domain object into SQL or ORM operations.
- Talks to the database.
- Returns persisted objects or database rows.
- Back up to presentation layer
- The controller turns the returned task into a JSON response.
- Sets the HTTP status code and headers.
- Sends the response to the client.
In pseudocode:
# Presentation (API endpoint)
@app.post("/tasks")
def create_task_endpoint(body: CreateTaskBody, user=Depends(get_current_user)):
task = task_service.create_task(
user_id=user.id,
title=body.title,
description=body.description,
due_date=body.due_date,
)
return TaskResponse.from_domain(task)# Service layer
class TaskService:
def __init__(self, task_repo: TaskRepository):
self.task_repo = task_repo
def create_task(self, user_id, title, description, due_date):
if self.task_repo.exists_with_title(user_id, title):
raise DuplicateTaskTitleError()
task = Task(
id=None,
user_id=user_id,
title=title,
description=description,
due_date=due_date,
is_done=False,
)
saved_task = self.task_repo.save(task)
return saved_task# Data access layer (repository)
class TaskRepository:
def __init__(self, session: Session):
self.session = session
def exists_with_title(self, user_id, title) -> bool:
return (
self.session.query(TaskModel)
.filter_by(user_id=user_id, title=title)
.first()
is not None
)
def save(self, task: Task) -> Task:
model = TaskModel(
user_id=task.user_id,
title=task.title,
description=task.description,
due_date=task.due_date,
is_done=task.is_done,
)
self.session.add(model)
self.session.commit()
self.session.refresh(model)
return Task.from_model(model)Every part has a clear role. Presentation does HTTP, service does business rules, repository does data access.
Responsibilities of Each Layer
Presentation Layer
The presentation layer is the outer shell of your backend. In a web API, this usually means:
- HTTP routes, controllers, or path operations.
- Request parsing and validation.
- Mapping exceptions to HTTP status codes.
- Choosing response bodies and status codes.
It should not:
- Contain business rules.
For example, "a user cannot delete another user's task" is a business rule and should live in the service layer. - Know how the database works.
- Build SQL queries.
Example, what belongs in the presentation layer:
@app.delete("/tasks/{task_id}")
def delete_task_endpoint(task_id: int, user=Depends(get_current_user)):
task_service.delete_task(task_id=task_id, user_id=user.id)
return Response(status_code=204)This endpoint does not check permissions by itself. It delegates that to the service.
Service Layer
The service layer holds business logic and use cases. It answers questions like:
- Can this user perform this action?
- What happens when a task is completed?
- How do we enforce business rules such as limits, quotas, statuses?
In the service layer you:
- Combine data from multiple repositories.
- Apply validation that is based on business rules, not on basic data types.
- Enforce invariants, such as "an order must have at least one item".
Example of business rules in the service layer:
class TaskService:
def delete_task(self, task_id: int, user_id: int):
task = self.task_repo.get_by_id(task_id)
if task is None:
raise TaskNotFoundError()
if task.user_id != user_id:
raise PermissionDeniedError("Cannot delete another user's task")
if task.is_done is False and task.due_date is not None:
# Example of a business rule: you must mark as done before deleting
raise BusinessRuleError("Task must be completed before deletion")
self.task_repo.delete(task_id)The service layer calls repositories but does not know about SQL queries or ORM-specific details.
Data Access Layer
The data access layer isolates how data is stored and accessed. It is responsible for:
- Executing SQL or ORM queries.
- Mapping between domain objects and database rows.
- Handling low-level persistence details.
Typical elements:
- Repository classes, such as
UserRepository,TaskRepository. - ORM models and queries.
The service layer should talk to repositories through interfaces or clear methods, such as:
class TaskRepository:
def get_by_id(self, task_id: int) -> Optional[Task]:
...
def save(self, task: Task) -> Task:
...
def delete(self, task_id: int) -> None:
...The service layer does not need to know:
- Which database is used.
- Which columns exist.
- How joins are written.
This separation makes it easier to:
- Switch from SQLite to PostgreSQL.
- Use a different ORM.
- Use in-memory repositories in tests.
Allowed and Forbidden Layer Interactions
To keep layers clean, you must control which layer can talk to which.
Common rule:
- Presentation can call: service layer.
- Service can call: repositories and infrastructure.
- Data access can call: database or external storage.
- No one below calls upward.
A simple diagram:
| Caller | Can call | Should not call |
|---|---|---|
| Presentation | Service | Repositories directly, database directly |
| Service | Repositories, infrastructure | Controllers, HTTP request objects |
| Data access | Database drivers, ORM, cache | Controllers, HTTP, business rules |
Important rule
Do not let the presentation layer call the database or ORM directly. Always go through the service layer and repositories. This keeps business rules centralized and testable.
Example of a bad design:
@app.post("/tasks")
def create_task_endpoint(body: CreateTaskBody, user=Depends(get_current_user)):
# Bad: calling ORM from controller and putting rules here
existing = (
db_session.query(TaskModel)
.filter_by(user_id=user.id, title=body.title)
.first()
)
if existing:
raise HTTPException(status_code=400, detail="Duplicate title")
model = TaskModel(...)
db_session.add(model)
db_session.commit()
...This endpoint mixes HTTP handling and data access. It is harder to reuse and test.
Benefits of Layered Architecture
Using layers introduces some structure and overhead, but it brings significant benefits.
Easier Testing
- You can test the service layer using fake repositories in memory.
- You can test the data access layer by itself, focusing on SQL queries.
- You can test the presentation layer using a test client, mocking services.
Example, unit test for the service with a fake repository:
class FakeTaskRepository(TaskRepository):
def __init__(self):
self.tasks = []
def exists_with_title(self, user_id, title):
return any(t.user_id == user_id and t.title == title for t in self.tasks)
def save(self, task: Task) -> Task:
task.id = len(self.tasks) + 1
self.tasks.append(task)
return task
def test_create_task_rejects_duplicate_title():
repo = FakeTaskRepository()
service = TaskService(task_repo=repo)
first = service.create_task(1, "Buy milk", "desc", None)
try:
service.create_task(1, "Buy milk", "another", None)
assert False, "Expected DuplicateTaskTitleError"
except DuplicateTaskTitleError:
passThe test focuses on business rules, not on HTTP or the database.
Clearer Responsibilities
When each layer has a single purpose, you avoid "god classes" that do everything.
Examples:
- Need to change a business rule? Look at the service layer.
- Need to optimize a query? Look at the data access layer.
- Need to change an endpoint URL? Look at the presentation layer.
Easier to Evolve
As your application grows, you might:
- Add a new API format, such as gRPC.
- Add a CLI tool.
- Add background workers that reuse the same business rules.
With layered architecture, you can reuse the service layer across all these entry points.
For example:
- HTTP endpoint calls
UserService.register_user. - CLI command calls the same
UserService.register_user. - Background job might also use
UserServiceto apply rules.
Simple Example Application Structure
A small FastAPI application using layers might use this folder structure:
app/
api/
routes/
tasks.py # presentation layer
services/
tasks.py # service layer
repositories/
tasks.py # data access layer
models/
domain/
task.py # domain entities
db/
task_model.py # ORM modelsExample content:
# app/models/domain/task.py
@dataclass
class Task:
id: int | None
user_id: int
title: str
description: str | None
is_done: bool# app/api/routes/tasks.py
@router.post("/tasks", response_model=TaskResponse)
def create_task_endpoint(body: CreateTaskBody, user=Depends(get_current_user)):
task = task_service.create_task(
user_id=user.id,
title=body.title,
description=body.description,
)
return TaskResponse.from_domain(task)# app/services/tasks.py
class TaskService:
def __init__(self, task_repo: TaskRepository):
self.task_repo = task_repo
...# app/repositories/tasks.py
class TaskRepository:
def __init__(self, session: Session):
self.session = session
...This simple structure already separates HTTP, business rules, and persistence.
Common Pitfalls and How to Avoid Them
Even when you use layers, some mistakes are frequent.
Putting Business Logic in the Wrong Layer
If you see a lot of business rules inside controllers or repositories, that is a warning sign.
Example, bad controller with business rules:
@app.post("/orders")
def create_order_endpoint(body: CreateOrderBody):
# Business rule: cannot order if user has unpaid invoices
unpaid = db_session.query(InvoiceModel).filter_by(user_id=body.user_id, paid=False)
if unpaid.count() > 0:
raise HTTPException(400, "Unpaid invoices")
...Better, move the rule into the service:
class OrderService:
def create_order(self, user_id, items):
if self.invoice_repo.has_unpaid_invoices(user_id):
raise UnpaidInvoicesError()
...
The controller then only calls order_service.create_order.
Layer Bypassing
Another issue is letting upper layers bypass the service layer and use repositories directly.
For example:
# Bad: controller uses both service and repository
@app.post("/tasks/{task_id}/done")
def mark_task_done(task_id: int):
task = task_repo.get_by_id(task_id)
task.is_done = True
task_repo.save(task)This bypasses any business rules in the service layer.
Correct version:
@app.post("/tasks/{task_id}/done")
def mark_task_done(task_id: int):
task_service.mark_done(task_id)
In TaskService.mark_done, you can enforce all rules consistently.
Overcomplicating Small Projects
For a tiny script or a single endpoint demo, a strict layered structure can feel heavy. Early on, you can start simple, but keep layers in mind.
A useful guideline:
Guideline
As soon as you:
- Have more than a few endpoints, or
- Need non-trivial business rules, or
- Need to talk to more than one data source,
introduce at least a service layer and a repository layer.
You can refactor gradually:
- Move database code into repositories.
- Move business logic into services.
- Leave controllers thin.
Summary
Layered architecture is about separating concerns into clear layers:
- Presentation layer handles HTTP and delegates work.
- Service layer holds business logic and use cases.
- Data access layer handles database interactions.
By controlling how layers interact and by keeping each layer focused, you get backends that are easier to test, maintain, and extend.
Views: 0
Where to Move
Move chapter:
- ☰ 1. Introduction to Backend Development
- ☰ 1.1. What Is Backend Development?
- ☰ 1.2. Frontend vs Backend
- ☰ 1.3. How Web Applications Work
- ☰ 1.4. Client-Server Architecture
- ☰ 1.5. Request-Response Cycle
- ☰ 1.6. Static vs Dynamic Websites
- ☰ 1.7. Backend Developer Responsibilities
- ☰ 1.8. Backend Development Roadmap
-
- ☰ 2. How the Web Works
- ☰ 2.1. The Internet and the Web
- ☰ 2.2. IP Addresses
- ☰ 2.3. Domain Names
- ☰ 2.4. DNS
- ☰ 2.5. Ports
- ☰ 2.6. TCP/IP Basics
- ☰ 2.7. HTTP and HTTPS
- ☰ 2.8. HTTP Requests
- ☰ 2.9. HTTP Responses
- ☰ 2.10. HTTP Methods
- ☰ 2.11. HTTP Status Codes
- ☰ 2.12. HTTP Headers
- ☰ 2.13. Cookies
- ☰ 2.14. Sessions
- ☰ 2.15. What Happens When You Enter a URL?
-
- ☰ 3. Development Environment
- ☰ 3.1. Choosing an Operating System
- ☰ 3.2. Linux Basics for Backend Developers
- ☰ 3.3. Command Line Basics
- ☰ 3.4. Environment Variables
- ☰ 3.5. Installing Development Tools
- ☰ 3.6. Code Editors and IDEs
- ☰ 3.7. Git
- ☰ 3.8. GitHub and GitLab
- ☰ 3.9. Creating Your First Repository
- ☰ 3.10. Branches and Commits
- ☰ 3.11. Basic Git Workflow
-
- ☰ 4. Programming Fundamentals
- ☰ 4.1. Variables and Data Types
- ☰ 4.2. Operators
- ☰ 4.3. Conditions
- ☰ 4.4. Loops
- ☰ 4.5. Functions
- ☰ 4.6. Data Structures
- ☰ 4.7. Error Handling
- ☰ 4.8. Modules and Packages
- ☰ 4.9. File Handling
- ☰ 4.10. Object-Oriented Programming
- ☰ 4.11. Classes and Objects
- ☰ 4.12. Inheritance and Composition
- ☰ 4.13. Clean Code Principles
-
- ☰ 5. Python for Backend Development
- ☰ 5.1. Introduction to Python
- ☰ 5.2. Installing Python
- ☰ 5.3. Virtual Environments
- ☰ 5.4. pip and Package Management
- ☰ 5.5. Python Project Structure
- ☰ 5.6. Functions and Type Hints
- ☰ 5.7. Classes and Dataclasses
- ☰ 5.8. Exceptions
- ☰ 5.9. Working with Files
- ☰ 5.9.1. File Downloads
- ☰ 5.9.2. File Validation
- ☰ 5.9.3. Image Uploads
- ☰ 5.9.4. Local File Storage
- ☰ 5.9.5. Object Storage
- ☰ 5.9.6. S3-Compatible Storage
- ☰ 5.9.7. Presigned URLs
- ☰ 5.9.8. Secure File Handling
-
- ☰ 5.10. JSON
- ☰ 5.11. Date and Time
- ☰ 5.12. Logging
- ☰ 5.13. Configuration
- ☰ 5.14. Environment Variables
- ☰ 5.15. Async Programming
- ☰ 5.16. Python Backend Best Practices
-
- ☰ 6. Introduction to Web Backends
- ☰ 6.1. Building a Simple Web Server
- ☰ 6.2. Routing
- ☰ 6.3. URL Parameters
- ☰ 6.4. Query Parameters
- ☰ 6.5. Request Bodies
- ☰ 6.6. Form Data
- ☰ 6.7. JSON Requests
- ☰ 6.8. Returning Responses
- ☰ 6.9. Templates
- ☰ 6.10. Static Files
- ☰ 6.11. Middleware
- ☰ 6.12. Application Configuration
-
- ☰ 7. REST APIs
- ☰ 7.1. What Is an API?
- ☰ 7.2. What Is REST?
- ☰ 7.3. Resources and Endpoints
- ☰ 7.4. RESTful URL Design
- ☰ 7.5. HTTP Methods in REST
- ☰ 7.6. GET Requests
- ☰ 7.7. POST Requests
- ☰ 7.8. PUT Requests
- ☰ 7.9. PATCH Requests
- ☰ 7.10. DELETE Requests
- ☰ 7.11. Request Validation
- ☰ 7.12. Response Models
- ☰ 7.13. HTTP Status Codes
- ☰ 7.14. Error Responses
- ☰ 7.15. Pagination
- ☰ 7.16. Filtering
- ☰ 7.17. Sorting
- ☰ 7.18. Searching
- ☰ 7.19. API Versioning
- ☰ 7.20. API Documentation
- ☰ 7.21. OpenAPI and Swagger
-
- ☰ 8. FastAPI
- ☰ 8.1. Introduction to FastAPI
- ☰ 8.2. Routes and Path Operations
- ☰ 8.3. Path Parameters
- ☰ 8.4. Pydantic Models
- ☰ 8.5. Data Validation
- ☰ 8.6. Dependency Injection
- ☰ 8.7. Exception Handling
- ☰ 8.8. Background Tasks
- ☰ 8.9. File Uploads
- ☰ 8.10. Async Endpoints
- ☰ 8.11. FastAPI Project Structure
- ☰ 8.12. Building a Complete REST API
-
- ☰ 9. Databases
- ☰ 9.1. Introduction to Databases
- ☰ 9.2. Relational vs NoSQL Databases
- ☰ 9.3. Tables, Rows, and Columns
- ☰ 9.4. Primary Keys
- ☰ 9.5. Foreign Keys
- ☰ 9.6. Relationships
- ☰ 9.7. One-to-One Relationships
- ☰ 9.8. One-to-Many Relationships
- ☰ 9.9. Many-to-Many Relationships
- ☰ 9.10. Database Schema Design
- ☰ 9.11. Normalization
- ☰ 9.12. Indexes
- ☰ 9.13. Transactions
- ☰ 9.14. ACID Properties
-
- ☰ 10. SQL
- ☰ 10.1. Introduction to SQL
- ☰ 10.2. CREATE
- ☰ 10.3. INSERT
- ☰ 10.4. SELECT
- ☰ 10.5. UPDATE
- ☰ 10.6. DELETE
- ☰ 10.7. WHERE
- ☰ 10.8. ORDER BY
- ☰ 10.9. GROUP BY
- ☰ 10.10. Aggregate Functions
- ☰ 10.11. JOINs
- ☰ 10.12. Subqueries
- ☰ 10.13. Constraints
- ☰ 10.14. Indexes
- ☰ 10.15. Transactions
- ☰ 10.16. Common Table Expressions
- ☰ 10.17. SQL Performance Basics
-
- ☰ 11. PostgreSQL
- ☰ 11.1. Introduction to PostgreSQL
- ☰ 11.2. Installing PostgreSQL
- ☰ 11.3. Creating Databases
- ☰ 11.4. Users and Roles
- ☰ 11.5. Permissions
- ☰ 11.6. PostgreSQL Data Types
- ☰ 11.7. Constraints
- ☰ 11.8. Indexes
- ☰ 11.9. Transactions
- ☰ 11.10. JSON Data
- ☰ 11.11. Backup and Restore
- ☰ 11.12. PostgreSQL Performance Basics
-
- ☰ 12. ORM and Database Integration
- ☰ 12.1. What Is an ORM?
- ☰ 12.2. SQLAlchemy
- ☰ 12.3. Models
- ☰ 12.4. Database Sessions
- ☰ 12.5. Creating Records
- ☰ 12.6. Reading Records
- ☰ 12.7. Updating Records
- ☰ 12.8. Deleting Records
- ☰ 12.9. Relationships
- ☰ 12.10. Queries
- ☰ 12.11. Transactions
- ☰ 12.12. Connection Pooling
- ☰ 12.13. Database Migrations
- ☰ 12.14. Alembic
- ☰ 12.15. Repository Pattern
-
- ☰ 13. Authentication
- ☰ 13.1. Authentication vs Authorization
- ☰ 13.2. Password Storage
- ☰ 13.3. Password Hashing
- ☰ 13.4. Registration
- ☰ 13.5. Login
- ☰ 13.6. Tokens
- ☰ 13.7. JSON Web Tokens
- ☰ 13.8. Access Tokens
- ☰ 13.9. Refresh Tokens
- ☰ 13.10. OAuth 2.0
- ☰ 13.11. OpenID Connect
- ☰ 13.12. Social Login
- ☰ 13.13. Logout
- ☰ 13.14. Password Reset
- ☰ 13.15. Email Verification
- ☰ 13.16. Multi-Factor Authentication
-
- ☰ 14. Authorization
- ☰ 14.1. Users and Permissions
- ☰ 14.2. Role-Based Access Control
- ☰ 14.3. Permission-Based Access Control
- ☰ 14.4. Protecting API Endpoints
- ☰ 14.5. Admin Permissions
- ☰ 14.6. Resource Ownership
- ☰ 14.7. Authorization Best Practices
-
- ☰ 15. Backend Security
- ☰ 15.1. Introduction to Web Security
- ☰ 15.2. HTTPS and TLS
- ☰ 15.3. SQL Injection
- ☰ 15.4. Cross-Site Scripting
- ☰ 15.5. Cross-Site Request Forgery
- ☰ 15.6. CORS
- ☰ 15.7. Authentication Attacks
- ☰ 15.8. Brute-Force Protection
- ☰ 15.9. Rate Limiting
- ☰ 15.10. Input Validation
- ☰ 15.11. Secure Password Storage
- ☰ 15.12. Secrets Management
- ☰ 15.13. Secure Cookies
- ☰ 15.14. Security Headers
- ☰ 15.15. File Upload Security
- ☰ 15.16. Dependency Vulnerabilities
- ☰ 15.17. OWASP Top 10
-
- ☰ 16. Caching
- ☰ 16.1. Why Caching Matters
- ☰ 16.2. Application Caching
- ☰ 16.3. Redis
- ☰ 16.3.1. Introduction to Redis
- ☰ 16.3.2. Installing Redis
- ☰ 16.3.3. Keys and Values
- ☰ 16.3.4. Expiration
- ☰ 16.3.5. Distributed Locks
-
- ☰ 16.4. Cache Keys
- ☰ 16.5. Cache Invalidation
- ☰ 16.6. Caching Database Queries
- ☰ 16.7. Distributed Caching
-
- ☰ 17. Background Processing
- ☰ 17.1. Synchronous vs Asynchronous Tasks
- ☰ 17.2. Background Jobs
- ☰ 17.3. Message Queues
- ☰ 17.4. Celery
- ☰ 17.5. Redis as a Message Broker
- ☰ 17.6. Scheduled Tasks
- ☰ 17.7. Retry Strategies
- ☰ 17.8. Handling Failed Jobs
- ☰ 17.9. Email Jobs
- ☰ 17.10. Long-Running Tasks
-
- ☰ 18. Email
- ☰ 18.1. How Email Works
- ☰ 18.2. SMTP
- ☰ 18.3. Sending Emails
- ☰ 18.4. HTML Emails
- ☰ 18.5. Transactional Emails
- ☰ 18.6. Password Reset Emails
- ☰ 18.7. Background Email Delivery
- ☰ 18.8. Email Delivery Best Practices
-
- ☰ 19. Testing
- ☰ 19.1. Why Backend Testing Matters
- ☰ 19.2. Unit Testing
- ☰ 19.3. Integration Testing
- ☰ 19.4. API Testing
- ☰ 19.5. pytest
- ☰ 19.6. Fixtures
- ☰ 19.7. Mocking
- ☰ 19.8. Testing Databases
- ☰ 19.9. Testing Authentication
- ☰ 19.10. Testing FastAPI
- ☰ 19.11. Test Coverage
- ☰ 19.12. Automated Testing
-
- ☰ 20. Logging and Monitoring
- ☰ 20.1. Application Logging
- ☰ 20.2. Log Levels
- ☰ 20.3. Structured Logging
- ☰ 20.4. Request Logging
- ☰ 20.5. Error Logging
- ☰ 20.6. Metrics
- ☰ 20.7. Health Checks
- ☰ 20.8. Monitoring
- ☰ 20.9. Prometheus
- ☰ 20.10. Grafana
- ☰ 20.11. Alerting
- ☰ 20.12. Error Tracking
- ☰ 20.13. Observability Basics
-
- ☰ 21. Docker
- ☰ 21.1. Introduction to Containers
- ☰ 21.2. Docker Architecture
- ☰ 21.3. Images
- ☰ 21.4. Containers
- ☰ 21.5. Dockerfiles
- ☰ 21.6. Building Images
- ☰ 21.7. Running Containers
- ☰ 21.8. Volumes
- ☰ 21.9. Networks
- ☰ 21.10. Docker Compose
- ☰ 21.11. FastAPI with Docker
- ☰ 21.12. PostgreSQL with Docker
- ☰ 21.13. Redis with Docker
- ☰ 21.14. Multi-Container Applications
- ☰ 21.15. Production Docker Best Practices
-
- ☰ 22. Web Servers and Reverse Proxies
- ☰ 22.1. Application Servers
- ☰ 22.2. Uvicorn
- ☰ 22.3. Gunicorn
- ☰ 22.4. Reverse Proxies
- ☰ 22.5. Nginx
- ☰ 22.6. Traefik
- ☰ 22.7. HTTPS
- ☰ 22.8. TLS Certificates
- ☰ 22.9. Let's Encrypt
- ☰ 22.10. Load Balancing
-
- ☰ 23. Deployment
- ☰ 23.1. Development vs Production
- ☰ 23.2. Preparing an Application for Production
- ☰ 23.3. Linux Server Setup
- ☰ 23.4. Deploying with Docker
- ☰ 23.5. Environment Configuration
- ☰ 23.6. Managing Secrets
- ☰ 23.7. HTTPS Configuration
- ☰ 23.8. Production Logging
- ☰ 23.9. Backups
- ☰ 23.10. Zero-Downtime Deployment
- ☰ 23.11. Rollbacks
-
- ☰ 24. CI/CD
- ☰ 24.1. Introduction to CI/CD
- ☰ 24.2. Continuous Integration
- ☰ 24.3. Continuous Delivery
- ☰ 24.4. Continuous Deployment
- ☰ 24.5. CI/CD Pipelines
- ☰ 24.6. GitHub Actions
- ☰ 24.7. GitLab CI/CD
- ☰ 24.8. Building Docker Images
- ☰ 24.9. Container Registries
- ☰ 24.10. Deployment Pipelines
- ☰ 24.11. Staging Environments
- ☰ 24.12. Production Environments
- ☰ 24.13. Rollback Strategies
-
- ☰ 25. Backend Architecture
- ☰ 25.1. Monolithic Architecture
- ☰ 25.2. Modular Monoliths
- ☰ 25.3. Microservices
- ☰ 25.4. Layered Architecture
- ☰ 25.5. Service Layer
- ☰ 25.6. Separation of Concerns
- ☰ 25.7. Domain-Driven Design Basics
- ☰ 25.8. Event-Driven Architecture
- ☰ 25.9. Choosing an Architecture
-
- ☰ 26. Performance and Scalability
- ☰ 26.1. Understanding Backend Performance
- ☰ 26.2. CPU-Bound vs I/O-Bound Work
- ☰ 26.3. Asynchronous Programming
- ☰ 26.4. Database Optimization
- ☰ 26.5. Query Optimization
- ☰ 26.6. Indexing
- ☰ 26.7. Load Balancing
- ☰ 26.8. Horizontal Scaling
- ☰ 26.9. Vertical Scaling
- ☰ 26.10. Stateless Applications
- ☰ 26.11. Performance Testing
- ☰ 26.12. Load Testing
-
- ☰ 27. Advanced API Development
- ☰ 27.1. WebSockets
- ☰ 27.2. Server-Sent Events
- ☰ 27.3. GraphQL
- ☰ 27.4. Webhooks
- ☰ 27.5. Idempotency
- ☰ 27.6. API Rate Limiting
- ☰ 27.7. API Keys
- ☰ 27.8. API Gateways
- ☰ 27.9. Distributed APIs
- ☰ 27.10. Real-Time Applications
-
- ☰ 28. Production Backend Engineering
- ☰ 28.1. Configuration Management
- ☰ 28.2. Database Backups
- ☰ 28.3. Disaster Recovery
- ☰ 28.4. Graceful Shutdown
- ☰ 28.5. Fault Tolerance
- ☰ 28.6. Circuit Breakers
- ☰ 28.7. High Availability
- ☰ 28.8. Monitoring Production Systems
- ☰ 28.9. Incident Response
-
- ☰ 29. Project 1: Task Management API
- ☰ 29.1. Project Requirements
- ☰ 29.2. Project Structure
- ☰ 29.3. Database Design
- ☰ 29.4. CRUD Operations
- ☰ 29.5. Validation
-
- ☰ 30. Project 2: Authentication System
- ☰ 30.1. User Registration
- ☰ 30.2. JWT Authentication
- ☰ 30.3. Role-Based Authorization
- ☰ 30.4. Security Testing
-
- ☰ 31. Project 3: E-Commerce Backend
- ☰ 31.1. Architecture
- ☰ 31.2. User Management
- ☰ 31.3. Product Management
- ☰ 31.4. Categories
- ☰ 31.5. Shopping Cart
- ☰ 31.6. Orders
- ☰ 31.7. Inventory
- ☰ 31.8. Payments
- ☰ 31.9. Admin API
-
- ☰ 32. Final Project: Production Backend
- ☰ 32.1. Planning the Application
- ☰ 32.2. Designing the Architecture
- ☰ 32.3. Designing the Database
- ☰ 32.4. Building the REST API
- ☰ 32.5. Authentication and Authorization
- ☰ 32.6. PostgreSQL Integration
- ☰ 32.7. Redis Integration
- ☰ 32.8. Background Workers
- ☰ 32.9. File Storage
- ☰ 32.10. Dockerizing the Application
- ☰ 32.11. CI/CD Pipeline
- ☰ 32.12. Production Deployment
- ☰ 32.13. HTTPS and Domain Setup
- ☰ 32.14. Performance Optimization
- ☰ 32.15. Security Review
- ☰ 32.16. Documentation
-
- ☰ 33. Backend Developer Roadmap
- ☰ 33.1. What You Should Know Now
- ☰ 33.2. Building a Portfolio
- ☰ 33.3. Creating Backend Projects
- ☰ 33.4. Contributing to Open Source
- ☰ 33.5. Preparing for Backend Interviews
- ☰ 33.6. Backend Interview Questions
- ☰ 33.7. Database Interview Questions
- ☰ 33.8. API Interview Questions
- ☰ 33.9. Linux and Docker Interview Questions
- ☰ 33.10. Where to Go Next
-
Comments
Please login to add a comment.
Don't have an account? Register now!