25.5. Service Layer
Table of Contents
Why a Service Layer Exists
In most backend applications you do not want your routes or controllers to talk directly to the database or external services. That makes the code hard to change, test, and understand.
A service layer is a set of classes or functions that contain your application’s business logic. Routes call services, and services talk to repositories, external APIs, queues, and other infrastructure.
A very simple mental picture:
[ HTTP Route / Controller ]
↓
[ Service Layer ]
↓
[ Repositories, APIs, etc. ]
↓
[ Database ]The service layer answers questions like:
- “What happens when a user registers?”
- “How do we create an order?”
- “What checks happen when someone cancels an order?”
It is not concerned with HTTP details, response models, or SQL syntax. It is concerned with rules and workflows.
Key rule: Put business rules and application workflows in the service layer, not in controllers or repositories.
Responsibilities of the Service Layer
The service layer sits between the web / API layer and the data access layer. It has some very specific responsibilities.
Orchestrating Use Cases
Each service method usually corresponds to a use case or application action. For example:
register_userlogin_usercreate_ordercancel_orderadd_item_to_cart
Each of these methods coordinates multiple steps:
Example: create_order
- Load the user and cart from the database.
- Check inventory for each product.
- Calculate prices, taxes, and discounts.
- Create an order record.
- Reserve inventory.
- Publish an “order_created” event to a message queue.
- Return the created order.
In a service-oriented design, the controller does something like:
order = order_service.create_order(user_id=user.id)
return OrderResponse.from_order(order)The controller does not know how to create the order. It just asks the service.
Enforcing Business Rules
Business rules describe how your system should behave. Examples:
- “A user cannot place an order if their account is banned.”
- “An order cannot be shipped if payment is not captured.”
- “A password must be at least 12 characters long.”
These rules live in the service layer (or in domain entities, if you use DDD), not in the controller or repository.
Example in pseudo Python:
class OrderService:
def ship_order(self, order_id: int, current_user: User):
order = self.order_repo.get(order_id)
if not current_user.is_admin:
raise PermissionError("Only admins can ship orders")
if order.status != "paid":
raise ValueError("Order must be paid before shipping")
order.status = "shipped"
self.order_repo.save(order)
self.events.publish("order_shipped", order_id=order.id)The controller might only handle:
try:
order_service.ship_order(order_id, current_user)
return {"status": "ok"}
except PermissionError:
raise HTTPException(status_code=403)
except ValueError as exc:
raise HTTPException(status_code=400, detail=str(exc))Rules live in the service, HTTP mapping lives in the controller.
Coordinating Multiple Repositories and Services
Often a use case touches multiple tables or external systems. The service layer is the place where you coordinate them.
Example: “User deletes their account”
Steps:
- Mark user as deleted.
- Cancel active subscriptions via payment gateway.
- Remove user sessions from Redis.
- Anonymize or delete user data in analytics.
- Send confirmation email.
A service method might look like:
class AccountService:
def delete_account(self, user_id: int):
user = self.user_repo.get(user_id)
self.payment_gateway.cancel_subscriptions(user)
self.session_store.remove_sessions(user_id)
self.analytics_service.anonymize_user(user_id)
user.is_deleted = True
self.user_repo.save(user)
self.email_service.send_account_deleted_email(user.email)No HTTP, no SQL queries here, only coordination of other abstractions.
Managing Transactions at the Use Case Level
The service layer is the right place to decide when a transaction begins and ends.
Example:
class OrderService:
def __init__(self, order_repo, inventory_repo, unit_of_work):
self.order_repo = order_repo
self.inventory_repo = inventory_repo
self.uow = unit_of_work
def create_order(self, user_id: int) -> Order:
with self.uow.transaction():
order = self.order_repo.create_empty(user_id)
items = self.inventory_repo.get_cart_items(user_id)
for item in items:
if item.stock <= 0:
raise ValueError("Out of stock")
self.inventory_repo.reserve(item)
order.items = items
self.order_repo.save(order)
return order
Inside with self.uow.transaction(): all repository calls share the same database transaction.
Important: Transactions should usually wrap a whole use case, not individual repository calls, so that either the entire operation succeeds or it all fails.
What the Service Layer Should Not Do
To keep boundaries clear, it helps to know what does not belong in the service layer.
No HTTP Details
Avoid:
RequestorResponseobjects.- Query parameters and path parameters.
- HTTP status codes.
A bad example:
# Bad: service returning HTTP exceptions
class UserService:
def register(self, request: Request):
if "email" not in request.json:
raise HTTPException(400, "Missing email")Better:
# Good: service deals with plain data and domain concepts
class UserService:
def register(self, email: str, password: str) -> User:
if not email:
raise ValueError("Email is required")
# ...
return userController:
def register_user_endpoint(body: RegisterRequest):
try:
user = user_service.register(body.email, body.password)
except ValueError as exc:
raise HTTPException(status_code=400, detail=str(exc))
return UserResponse.from_user(user)No SQL or ORM Queries
The service layer should talk to repositories or data access objects, not to the ORM or database directly.
Bad:
class OrderService:
def list_orders(self):
return session.query(Order).filter(Order.status == "paid").all()Good:
class OrderService:
def list_paid_orders(self):
return self.order_repo.list_by_status("paid")Repository:
class SqlAlchemyOrderRepository:
def list_by_status(self, status: str) -> list[Order]:
return (
self.session.query(Order)
.filter(Order.status == status)
.all()
)This makes it easier to swap databases or to test the service with in-memory repositories.
No Framework-Specific Logic
Try to keep the service layer independent of your web framework. No FastAPI decorators, no Flask globals, etc.
This helps when:
- You change frameworks later.
- You want to reuse logic in a CLI tool or batch script.
- You write unit tests without spinning up the web server.
Example: Service Layer in a Simple Application
Imagine a very small task management API. You might have layers like this:
| Layer | Example components | Knows about |
|---|---|---|
| Presentation | FastAPI routes, request & response models | HTTP, JSON, auth tokens |
| Service layer | TaskService, UserService | Business rules, use cases |
| Data access layer | Repositories, ORM models | Database, SQL / ORM |
| Infrastructure | Email sender, payment gateway client, Redis | External systems, protocols |
A simple workflow: “Create a task”
Controller (FastAPI endpoint)
@router.post("/tasks", response_model=TaskResponse)
def create_task(
body: CreateTaskRequest,
current_user: User = Depends(get_current_user),
):
task = task_service.create_task(
title=body.title,
description=body.description,
owner_id=current_user.id,
)
return TaskResponse.from_task(task)Service layer
class TaskService:
def __init__(self, task_repo, event_bus):
self.task_repo = task_repo
self.event_bus = event_bus
def create_task(self, title: str, description: str, owner_id: int) -> Task:
if not title or len(title) < 3:
raise ValueError("Title must be at least 3 characters")
task = Task(title=title, description=description, owner_id=owner_id)
self.task_repo.add(task)
self.event_bus.publish("task_created", {"task_id": task.id})
return taskRepository
class SqlAlchemyTaskRepository:
def __init__(self, session):
self.session = session
def add(self, task: Task):
self.session.add(task)
self.session.commit()Notice:
- Controllers handle HTTP concerns.
- Service handles validation and orchestration.
- Repository handles persistence.
Designing Service Interfaces
How you design the methods in your service layer affects readability and usability.
Use Use-Case Oriented Methods
Service methods should sound like actions or use cases, not low-level operations.
Compare:
- Bad:
get,save,update,delete - Better:
register_user,change_password,add_product_to_cart,checkout_cart
Good names make controllers satisfy a rule like: “One endpoint calls one service method.”
Example mapping:
| Endpoint | Service method |
|---|---|
POST /users | user_service.register_user |
POST /login | auth_service.login |
POST /orders | order_service.create_order |
PATCH /orders/{id} | order_service.update_order |
POST /orders/{id}/pay | payment_service.pay_order |
Accept and Return Domain Types
Prefer passing simple values and domain objects, not framework objects.
Bad:
def create_order(self, request: Request) -> Response:
# service is tied to HTTPGood:
def create_order(
self,
user_id: int,
items: list[OrderItemInput],
) -> Order:
# no HTTP knowledgeIf you use data classes or Pydantic models for domain data, create separate request / response models in the API layer, and convert between them.
Handle Errors with Exceptions
Let the service layer raise domain-specific exceptions and let the controller map them to HTTP responses.
Example:
class OutOfStockError(Exception):
pass
class OrderNotFoundError(Exception):
pass
class OrderService:
def cancel_order(self, order_id: int, user_id: int):
order = self.order_repo.get(order_id)
if not order:
raise OrderNotFoundError()
if order.user_id != user_id:
raise PermissionError("Not your order")
if order.status == "shipped":
raise ValueError("Cannot cancel shipped order")
order.status = "cancelled"
self.order_repo.save(order)Controller:
@router.post("/orders/{order_id}/cancel")
def cancel_order(order_id: int, current_user: User = Depends(get_current_user)):
try:
order_service.cancel_order(order_id, current_user.id)
except OrderNotFoundError:
raise HTTPException(status_code=404, detail="Order not found")
except PermissionError:
raise HTTPException(status_code=403, detail="Forbidden")
except ValueError as exc:
raise HTTPException(status_code=400, detail=str(exc))
return {"status": "cancelled"}Service Layer and Other Architectural Patterns
The service layer often appears together with other patterns that you have in the outline.
With the Repository Pattern
The repository pattern abstracts persistence. The service layer uses repositories instead of using ORM sessions or SQL directly.
Typical dependencies:
class UserService:
def __init__(self, user_repo: UserRepository, email_service: EmailService):
self.user_repo = user_repo
self.email_service = email_serviceRepositories hide the details of PostgreSQL or any other database. Services focus on rules like “user must verify email before logging in.”
With Domain-Driven Design (DDD)
In DDD you will see terms like:
- Entities: domain objects with identity.
- Value objects: small immutable value types.
- Domain services: operations that do not naturally belong to an entity.
You can think of the “service layer” in two ways:
- Application services: orchestrate use cases, call repositories, manage transactions.
- Domain services: pure business logic operations that work with entities and value objects.
A typical setup:
# Application service
class PaymentApplicationService:
def pay_order(self, order_id: int, payment_details: PaymentDetails):
order = self.order_repo.get(order_id)
payment = self.payment_domain_service.pay(order, payment_details)
self.payment_repo.save(payment)The important point is that the application service is still the boundary between the outside world and the domain.
With Dependency Injection
Services are often wired with dependency injection:
- In small apps, you may manually instantiate services in a module and reuse them.
- In larger apps, you may use a DI container.
Example with manual wiring in a FastAPI app:
# wiring.py
session_factory = create_session_factory()
user_repo = SqlAlchemyUserRepository(session_factory)
email_service = SmtpEmailService(settings.smtp)
user_service = UserService(user_repo=user_repo, email_service=email_service)Route:
@router.post("/users")
def register_user(body: RegisterRequest):
user = user_service.register(body.email, body.password)
return UserResponse.from_user(user)DI keeps your service constructors explicit, which makes them easy to test.
Testing the Service Layer
The service layer is a sweet spot for unit tests, because it:
- Contains important logic.
- Can often be tested without HTTP or a real database.
Testing with In-Memory or Fake Repositories
Instead of using the real database, you can write a simple in-memory repository that implements the same interface.
Example:
class InMemoryUserRepository:
def __init__(self):
self._users = {}
self._next_id = 1
def add(self, user: User):
user.id = self._next_id
self._next_id += 1
self._users[user.id] = user
def get_by_email(self, email: str) -> User | None:
return next((u for u in self._users.values() if u.email == email), None)Test:
def test_register_user_creates_user_and_sends_email():
repo = InMemoryUserRepository()
email_service = FakeEmailService()
service = UserService(user_repo=repo, email_service=email_service)
user = service.register("a@example.com", "password123")
assert user.id is not None
assert email_service.sent_to == ["a@example.com"]No HTTP request, no database, only logic being tested.
Testing Business Rules
You can write many small tests that verify the rules inside your services.
Examples of test scenarios for an order service:
- Cannot cancel shipped order.
- Only admin can change order price.
- Cannot create an order for banned user.
- Discount is applied correctly when there are more than 3 items.
These tests help you change implementation later without breaking behavior.
Rule for testable design: If it is hard to test a piece of logic without HTTP and a real database, that logic is probably not in the service layer where it belongs.
When a Service Layer Is Overkill
For very small scripts or simple prototypes, a formal service layer can feel like too much structure:
- A single-file FastAPI app that does simple CRUD.
- A temporary internal tool.
In such cases, you may allow some logic in controllers.
However, as soon as:
- You add real business rules.
- Multiple controllers share logic.
- You need solid tests.
it becomes beneficial to introduce services.
A minimal first step is often:
- Extract non-trivial logic from endpoints into plain functions like
def create_order(...). - Later, group those functions into classes like
OrderService.
Practical Guidelines
To use a service layer effectively, keep these guidelines in mind.
What to Put in the Service Layer
- Business rules.
- Input validation that is about “business correctness,” not just “is this an integer.”
- Coordination of multiple repositories or systems.
- Transaction boundaries.
- Emitting domain events or integration events.
- Permission checks that depend on business context.
What to Keep Out of the Service Layer
- HTTP objects, status codes, or headers.
- Framework-specific abstractions.
- SQL queries, ORM session usage, or raw database connections.
- HTML templates or serialization logic.
Simple Checklist
When you write a new endpoint, ask:
- Does this endpoint do more than simply call a repository?
- Are there business rules or workflows involved?
- Might this logic be reused elsewhere?
If the answer is “yes” to any of these, create or extend a service and put the logic there. Let the controller be thin and focused on HTTP concerns only.
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!