19.3. Integration Testing
Table of Contents
Why Integration Testing Matters
Unit tests focus on small pieces of code in isolation. Integration tests focus on how pieces work together.
In backend development, most real bugs appear when different parts of the system interact, for example:
- API layer + business logic + database
- Authentication middleware + protected endpoints
- Background workers + queues + database
Integration testing helps you catch these problems before they appear in production.
Definition:
Integration testing checks that multiple components of your system work correctly together, using realistic inputs and infrastructure, such as a real or test database and real HTTP requests.
Unit tests ask:
"Does this function return the right result for this input?"
Integration tests ask:
"Given a running API and a database, does this endpoint behave correctly end to end?"
Unit Tests vs Integration Tests
You should already understand unit tests in this course, so here we only contrast them with integration tests.
Levels of Testing in a Backend
A simplified view:
| Level | What it tests | Speed | Typical tools |
|---|---|---|---|
| Unit tests | Single function / method | Very fast | pytest, unittest |
| Integration tests | Multiple components working together | Medium | pytest + HTTP client + test DB |
| End to end tests | Whole system from a user perspective | Slow | Browser tests, API tests with real deps |
Integration tests live between unit tests and full end to end tests.
What Integration Tests Usually Include
An integration test for a backend often involves:
- A running HTTP server or an in-process test client
- A real database engine, but usually a separate test database
- Real routing, middleware, serialization and validation
- Sometimes external services, but often replaced by test doubles (fakes, mocks)
Examples:
- Creating a user through
POST /usersand checking what is stored in the database - Logging in through
POST /auth/loginand checking the returned token and status code - Creating an order and ensuring that stock is reduced in the inventory table
What Integration Tests Look Like for Web Backends
Typical Integration Test Scenario
A classic backend integration test checks: HTTP request → application → database → HTTP response.
Example scenario in plain language:
- Start your API app in a test mode.
- Ensure the test database is empty.
- Send an HTTP
POST /usersrequest with JSON data. - Assert:
- HTTP status code is
201 Created. - JSON response contains the right fields.
- Query the test database directly.
- Assert:
- A new user exists with the expected values.
- Password was hashed, not stored in plain text.
This is already far beyond what any single unit test can guarantee.
Important Integration Test Properties
Integration tests are:
- Stateful
They often read and write to shared state, such as a database. You must reset this state between tests. - Slower
They involve I/O, network, and process start up. Use them wisely, not for every tiny detail. - Closer to real usage
They test the real configuration and glue code that unit tests usually skip.
When to Write Integration Tests
You do not need an integration test for every function. Focus on critical flows and boundaries.
Good Candidates for Integration Tests
These areas benefit a lot from integration testing:
| Area | Example integration tests |
|-------------------------------|-------------------------------------------------------------------------|
| Authentication & sessions | Login endpoint, token creation, token validation |
| Database access & transactions | Create, update, delete flows for important entities |
| Validation & error responses | Invalid payloads, missing fields, invalid types |
| Security critical behavior | Access control, permission checks, resource ownership |
| Cross-component workflows | Creating an order updates inventory and records a payment entry |
If a bug would be very harmful in production (security, money, data loss), it is usually worth an integration test.
When a Unit Test Is Enough
Prefer a unit test when:
- You are testing pure logic, such as a price calculation function.
- The logic does not depend on network, database, or frameworks.
- You want fast feedback on implementation details.
You can often do both:
- Unit test the internal logic for many edge cases.
- One or two integration tests to confirm the full flow.
Designing Integration Tests
Black Box vs White Box
You can treat your backend as a:
- Black box
You do not care about internal structure. You only use the public API.
Example: Use only HTTP endpoints and database as an implementation detail. - White box
You know the internals and sometimes reach into them for setup or checks.
Example: Calling internal services directly, or reading in-memory state.
Most backend integration tests are black box from the HTTP side, white box about the database:
- You call endpoints as a client.
- You inspect the test database to verify results.
Arrange, Act, Assert Pattern
Structure each test with three steps:
- Arrange
Set up test data and environment. For example, create a user in the database. - Act
Perform the primary action. For example, send an HTTP request to/login. - Assert
Check that the observable results match expectations. For example, token returned, status code is 200, database updated.
Example in pseudocode:
def test_login_success(integration_client, db_session):
# Arrange
create_user(db_session, email="test@example.com", password="correct_password")
# Act
response = integration_client.post("/login", json={
"email": "test@example.com",
"password": "correct_password",
})
# Assert
assert response.status_code == 200
data = response.json()
assert "access_token" in dataTest Only One Scenario per Test
Each integration test should check one clear scenario:
test_create_user_successtest_create_user_duplicate_email_returns_400test_create_user_missing_email_returns_422
If you combine many different error cases into a single test, it becomes hard to maintain and debug.
Integration Testing Strategy in Python Backends
You will see concrete tools in later chapters, especially when testing FastAPI. Here we focus on patterns, not specific libraries.
Typical Test Stack
A common setup for Python backend integration tests:
| Concern | Example choice (you will see details later) |
|---|---|
| Test runner | pytest |
| HTTP client | Framework test client or httpx |
| Test database | PostgreSQL instance or in memory SQLite (temporary) |
| Database cleanup | Fixtures or database transactions per test |
| Test configuration | Separate config for tests (test DB, no emails, etc.) |
Separate Configuration for Tests
Your application will have configuration for:
- Database URL
- Email provider credentials
- Secrets and API keys
- Debug / production flags
For integration tests you usually have separate values, for example:
| Environment | DB name | Email sending | Logging level |
|---|---|---|---|
| Development | app_dev | Maybe real or sandbox | DEBUG |
| Test (integration tests) | app_test | Disabled or fake | WARNING |
| Production | app_prod | Real | INFO |
Rule:
Never run integration tests against your production database or services.
Always use a separate test environment, preferably isolated and disposable.
This prevents real data loss, spam emails to users, or charges on real payment providers.
Handling Databases in Integration Tests
Most backend integration tests talk to a database. Handling it correctly is critical.
Using a Separate Test Database
Always point integration tests to a separate database instance or schema.
Example pattern:
- Environment variable
DATABASE_URLfor normal runs. - Environment variable
TEST_DATABASE_URLfor tests.
Your test setup:
- Reads
TEST_DATABASE_URL. - Creates the database or clears existing data.
- Runs migrations to create tables.
- Uses this database for all tests.
You can do this once per test session to reduce overhead.
Keeping Tests Independent
Integration tests often change database state. You must keep tests independent, so one test does not break another.
Common approaches:
| Approach | Idea | Pros | Cons |
|---|---|---|---|
| Truncate tables between tests | After each test, delete all rows from all tables | Simple to understand | Can be slow |
| Use DB transactions per test | Start a transaction, run the test, then roll back | Very fast | Needs careful setup |
| Create a fresh DB per test class | Create a new temporary DB or schema for a group of tests (test class) | Good isolation between groups | More complex infrastructure |
A typical pattern:
- For each test function, start a transaction.
- Run the test inside this transaction.
- Roll back at the end, so the database is clean.
This makes integration tests more deterministic and easier to run in any order.
Testing Transactions and Constraints
Integration tests are perfect for checking:
- Foreign key constraints
- Unique constraints
- Transaction behavior
Example scenarios:
- Creating a child record with a non existing parent should fail.
- Creating two users with the same email should fail with a clean error.
- In a transactional operation, partial failure should roll back all changes.
You write an integration test that:
- Calls the endpoint or service that performs the transaction.
- Asserts the HTTP response is correct.
- Queries the database to check that data is exactly as expected, including no partial writes.
Testing HTTP APIs with Integration Tests
Since this course focuses on backend APIs, most integration tests will call HTTP endpoints.
Using a Test HTTP Client
Your framework will provide or support an HTTP client that can talk to your app in a test environment. The details differ, but the pattern is similar:
- Start the app with a test configuration.
- Use a client object, for example
client, to send HTTP requests. - Assert on response status, headers, JSON body.
Example shape in pseudocode:
def test_get_tasks_returns_list(client):
response = client.get("/tasks")
assert response.status_code == 200
data = response.json()
assert isinstance(data, list)For tests that change state:
def test_create_task_persists_in_db(client, db_session):
# Act
response = client.post("/tasks", json={"title": "Test task"})
assert response.status_code == 201
task_id = response.json()["id"]
# Assert in DB
task = db_session.get(Task, task_id)
assert task is not None
assert task.title == "Test task"Testing Error Handling
Integration tests are very useful for checking how errors are exposed to clients.
Examples:
- Sending invalid JSON should return
400 Bad Request. - Failing validation should return
422 Unprocessable Entitywith error details. - Accessing a protected resource without a token should return
401 Unauthorized.
You design tests such as:
def test_create_task_without_title_returns_422(client):
response = client.post("/tasks", json={})
assert response.status_code == 422
data = response.json()
# Exact structure depends on your framework
assert "errors" in dataThis ensures that clients of your API get predictable, documented errors.
Testing Authentication and Authorization
Integration tests can simulate:
- Authenticated requests with valid tokens.
- Requests with missing or invalid tokens.
- Requests with different roles or permissions.
Typical patterns:
- A fixture that logs in a test user and returns an access token.
- Using that token in
Authorizationheaders for subsequent requests.
Example structure:
def test_get_profile_requires_auth(client):
response = client.get("/me")
assert response.status_code == 401
def test_get_profile_returns_user_data(client, user_token):
response = client.get("/me", headers={"Authorization": f"Bearer {user_token}"})
assert response.status_code == 200
data = response.json()
assert data["email"] == "user@example.com"Working with External Dependencies
Backends rarely live alone. They send emails, call other services, and integrate with queues. Integration tests must address this.
Real Services vs Test Doubles
You often have two options for each external dependency:
- Use the real service
For example, a local Redis instance or a local message queue. - Use a test double
For example, an in memory fake implementation, or a mock.
A balanced strategy:
- For core infrastructure you control, such as a local PostgreSQL or Redis, you can often run the real thing in a test environment.
- For third party services, such as payment providers and external APIs, prefer fakes or mocks to avoid costs, rate limits, and instability.
Fakes vs Mocks in Integration Tests
Terminology:
- A fake is a lightweight implementation used only in tests, but behaves similarly to the real service.
- A mock is a test object that records or asserts calls and is usually created by a mocking library.
Integration tests often use fakes more than detailed mocks, because we want to test the interaction between many real components.
Example:
- Instead of sending real emails, use an email service that stores "sent emails" in memory.
- Integration tests can then assert that one email was "sent" to the right address.
Pseudo pattern:
def test_registration_sends_verification_email(client, fake_email_service):
response = client.post("/register", json={
"email": "new@example.com",
"password": "secret123"
})
assert response.status_code == 201
assert len(fake_email_service.sent_emails) == 1
assert fake_email_service.sent_emails[0].to == "new@example.com"This keeps tests deterministic and fast, while still checking that integration with the email service works logically.
Organizing Integration Tests
As your project grows, you need a clear structure for integration tests.
Separating Unit and Integration Tests
You can separate tests by:
- Directory:
tests/unit/tests/integration/- Naming:
- Unit tests:
test_*.py - Integration tests:
itest_*.py(or similar)
Then you can run them separately, for example:
pytest tests/unitfor fast checks.pytest tests/integrationbefore pushing or in CI.
Grouping by Feature or Module
Within tests/integration/, you can group by domain feature:
tests/integration/test_auth.pytests/integration/test_tasks.pytests/integration/test_orders.py
Inside each file, structure tests by endpoint or scenario:
# tests/integration/test_auth.py
def test_register_creates_user(...):
...
def test_register_duplicate_email_returns_400(...):
...
def test_login_success(...):
...This mirrors how your API is organized and makes tests easier to navigate.
Using Fixtures for Setup and Teardown
Integration tests often share setup logic, such as:
- Creating a test client.
- Creating test users in the database.
- Authenticating a user and getting a token.
You can use test fixtures (for example, pytest fixtures) to:
- Encapsulate common setup.
- Reuse it across many tests.
- Handle cleanup automatically.
Although we will not go deep into fixture code here, you will see patterns like:
clientfixture for a test HTTP client.db_sessionfixture for a database session.user_tokenfixture for an authenticated token.
Integration Testing in Continuous Integration (CI)
Integration tests are an important part of CI pipelines.
Where Integration Tests Fit in CI
A typical pipeline:
- Run linting tools.
- Run unit tests.
- Run integration tests.
- Build Docker images.
- Deploy to a test or staging environment.
You can choose:
- Run all tests on every push for small projects.
- Run unit tests on every push and integration tests on pull requests for larger projects.
Infrastructure in CI
To run integration tests in CI, you need infrastructure:
- A PostgreSQL or other database instance
- Possibly Redis or other dependencies
Common approaches:
- Use Docker services in CI configurations, for example a PostgreSQL container.
- Use tools like Docker Compose to start a full test stack.
- Initialize the test database at the start of the test job.
Your test code then uses TEST_DATABASE_URL pointing to the CI database container.
This allows integration tests to run in the same way locally and in CI, which increases reliability.
Common Pitfalls and Best Practices
Pitfalls
Here are common mistakes in integration testing:
| Pitfall | Problem |
|---|---|
| Using production resources | Risk of data loss, spam, costs |
| Tests depend on each other | Order dependent tests, flaky results |
| Too much mocking | Integration tests become similar to unit tests, lose their value |
| No cleanup of shared state | Database or cache polluted, tests interfere with each other |
| Oversized tests | Very long tests that cover too many cases, hard to debug and maintain |
| Ignoring non happy paths | Only success flow tested, errors in real use cause crashes |
Best Practices
Some useful rules of thumb:
Key rules for integration tests:
- Use a separate test environment and never touch production.
- Keep tests independent and repeatable. They should pass in any order.
- Focus on important flows and boundaries, not every small detail.
- Test both happy paths and failure paths for critical features.
- Automate running integration tests in your CI pipeline.
Additional tips:
- Start with a small set of high value integration tests for your core endpoints, such as authentication and main CRUD operations.
- Gradually expand coverage as your application grows.
- Keep integration tests focused and readable, even if they are longer than unit tests.
- When a bug is found in production that involves multiple components, consider writing an integration test that reproduces it, then fix the bug and keep the test as a regression check.
Summary
Integration testing verifies that multiple parts of your backend, such as HTTP endpoints, middleware, business logic, and the database, work together correctly.
You saw:
- How integration tests differ from unit tests.
- Which parts of a backend benefit most from integration testing.
- How to design good integration tests with clear Arrange, Act, Assert structure.
- Patterns for handling test databases and external dependencies.
- How to organize and run integration tests locally and in CI.
- Common pitfalls and best practices.
In later chapters, especially when testing FastAPI, you will apply these ideas with real code, HTTP clients, and test databases.
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!