19.6. Fixtures
Table of Contents
Understanding Fixtures
Fixtures are a way to prepare and share reusable test setup. They let you say: "To run this test, I need X to be ready," without repeating setup code in every test.
In this chapter we assume you already know basic testing ideas and pytest syntax. We focus on how fixtures work and how to use them effectively in backend projects.
Why Fixtures Are Useful
In backend tests you often need:
- A database connection with tables created
- Some example users, products, or tasks in the database
- A configured FastAPI or Flask test client
- Temporary files or directories
- Environment variables set for tests
Without fixtures, you tend to write the same setup code again and again:
def test_create_user():
db = create_test_db()
app = create_app(db)
client = app.test_client()
# test code
def test_get_user():
db = create_test_db()
app = create_app(db)
client = app.test_client()
# test codeFixtures allow you to define this setup once, then inject it into many tests:
import pytest
@pytest.fixture
def client():
db = create_test_db()
app = create_app(db)
return app.test_client()
def test_create_user(client):
response = client.post("/users", json={"name": "Alice"})
assert response.status_code == 201
def test_get_user(client):
response = client.get("/users/1")
assert response.status_code == 200The tests read more clearly, and setup is centralized and easy to change.
Key idea: A fixture is a function marked with @pytest.fixture that returns something your test needs, and pytest injects it into any test function that asks for it by name.
Basic pytest Fixture Syntax
A simple fixture looks like this:
import pytest
@pytest.fixture
def sample_user():
return {"id": 1, "name": "Alice"}You use it in a test by listing the fixture name as a parameter:
def test_user_has_name(sample_user):
assert sample_user["name"] == "Alice"
pytest sees that test_user_has_name needs sample_user, calls the sample_user fixture function, and passes its return value to the test.
Naming and return values
- The fixture name is the function name
- A fixture can return any Python object
- The test does not know or care how the fixture is created, only what it receives
Examples of common backend fixtures:
@pytest.fixture
def config():
return {"DEBUG": False, "DATABASE_URL": "sqlite:///:memory:"}
@pytest.fixture
def token():
return "test-token-123"
@pytest.fixture
def sample_todos():
return [
{"id": 1, "title": "Write docs"},
{"id": 2, "title": "Add tests"},
]Fixture Scope
By default, fixtures are created fresh for every test function that uses them. Sometimes you want to reuse the same fixture instance across multiple tests.
pytest supports scopes:
function(default)classmodulepackagesession
You control this with the scope argument:
@pytest.fixture(scope="function")
def user_function():
return {"id": 1}
@pytest.fixture(scope="module")
def db_connection():
print("Create DB connection")
return object()
@pytest.fixture(scope="session")
def redis_client():
print("Start Redis client")
return object()When to use which scope
A simple guideline for backend tests:
| Scope | Typical use in backend tests |
|---|---|
| function | Any state that must be clean for each test, for example an empty database, a fresh HTTP client, a new temporary directory |
| class | Shared expensive setup needed for all tests in one test class |
| module | Shared expensive setup needed for all tests in one test file |
| session | Very expensive or global resources, for example spinning up a Dockerized database for all tests |
Example of a module scoped database:
@pytest.fixture(scope="module")
def db():
# Run once for test file
db = create_test_db()
create_tables(db)
yield db
# Run once after all tests in this file
db.close()Setup and Teardown with yield
Often you need to set something up before the test, then clean it up after.
With pytest fixtures you use yield:
import pytest
@pytest.fixture
def temp_file(tmp_path):
file_path = tmp_path / "test.txt"
file_path.write_text("hello")
# Setup finished, give the file path to tests
yield file_path
# Code after yield is teardown
file_path.unlink() # delete fileThe test uses the fixture normally:
def test_temp_file_exists(temp_file):
assert temp_file.read_text() == "hello"Internally:
- Code before
yieldruns before the test - The value after
yieldis what the test receives - Code after
yieldruns after the test finishes
Backend example, FastAPI test client with database cleanup:
@pytest.fixture
def client():
db = create_test_db()
app = create_app(db)
test_client = app.test_client()
yield test_client
db.drop_all()
db.close()
Important rule: Use yield inside fixtures when you need both setup and teardown. All code after yield is guaranteed to run, even if the test fails.
Using Built‑in pytest Fixtures
pytest comes with some very useful fixtures, especially for file and path handling.
tmp_path: temporary directories
tmp_path creates a unique temporary directory for each test:
def test_write_file(tmp_path):
file_path = tmp_path / "data.txt"
file_path.write_text("Backend\n")
assert file_path.read_text() == "Backend\n"
You can wrap tmp_path into your own fixture:
@pytest.fixture
def log_file(tmp_path):
file_path = tmp_path / "app.log"
file_path.write_text("")
return file_path
def test_logging(log_file):
log_file.write_text("INFO: started\n")
assert "INFO" in log_file.read_text()monkeypatch: modifying environment and attributes
monkeypatch lets you change environment variables or attributes during tests.
Changing environment variable:
def test_env_config(monkeypatch):
monkeypatch.setenv("APP_ENV", "test")
assert load_env() == "test"Replacing a function:
import my_app
def fake_send_email(to, subject, body):
return True
def test_registration(monkeypatch):
monkeypatch.setattr(my_app, "send_email", fake_send_email)
assert my_app.register_user("alice@example.com") is TrueThis is very useful for backend tests that must not call real external services.
Composing Fixtures
Fixtures can depend on other fixtures. This is how you build layers of setup.
Example: database connection, then repository, then service:
@pytest.fixture
def db():
return create_test_db()
@pytest.fixture
def user_repository(db):
return UserRepository(db)
@pytest.fixture
def user_service(user_repository):
return UserService(user_repository)
def test_create_user(user_service):
user = user_service.create_user("alice@example.com")
assert user.email == "alice@example.com"pytest resolves dependencies by matching parameter names with fixture names.
Dependency tree example
user_service
└─ user_repository
└─ db
When a test needs user_service, pytest will:
- Create
db - Create
user_repository(db) - Create
user_service(user_repository) - Run your test with
user_service
This pattern matches backend architecture layers and keeps each piece testable.
Autouse Fixtures
Sometimes you want a fixture to run automatically for many or all tests without listing it explicitly.
You can use autouse=True:
@pytest.fixture(autouse=True)
def set_test_env(monkeypatch):
monkeypatch.setenv("ENV", "test")
Now every test in that file will have ENV="test".
Another example, automatically cleaning a global cache:
@pytest.fixture(autouse=True)
def clear_cache():
cache.clear()
Use autouse carefully:
- It makes tests shorter
- But it can hide what setup is happening, so prefer explicit fixtures unless you really want global behavior
Fixtures in conftest.py
If you define a fixture in a normal test file, only tests in that file can use it.
To share fixtures across multiple test files, put them in conftest.py:
tests/
conftest.py
test_users.py
test_orders.py
conftest.py example:
# tests/conftest.py
import pytest
from my_app import create_app, create_test_db
@pytest.fixture
def db():
db = create_test_db()
yield db
db.drop_all()
db.close()
@pytest.fixture
def client(db):
app = create_app(db)
return app.test_client()
Now both test_users.py and test_orders.py can simply use client and db:
# tests/test_users.py
def test_create_user(client):
response = client.post("/users", json={"email": "alice@example.com"})
assert response.status_code == 201
You do not need to import fixtures from conftest.py. pytest discovers them automatically.
Parameterized Fixtures
Sometimes you want the same fixture to provide multiple variations. For example, test with multiple database backends or various user roles.
You can parameterize a fixture:
@pytest.fixture(params=["user", "admin"])
def role(request):
return request.param
def test_access(role):
if role == "admin":
assert can_access_admin_panel(role) is True
else:
assert can_access_admin_panel(role) is False
pytest will run test_access twice:
- With
role == "user" - With
role == "admin"
Backend example, testing two hash algorithms:
@pytest.fixture(params=["bcrypt", "argon2"])
def hasher(request):
return get_hasher(algorithm=request.param)
def test_password_hashing(hasher):
password = "secret"
hashed = hasher.hash(password)
assert hasher.verify(password, hashed)This keeps your test code simple while covering multiple configurations.
Fixtures for Database Tests
Database tests are common in backend development, and fixtures are essential to:
- Create a test database
- Run migrations or create tables
- Provide a clean state for each test
- Roll back changes after each test
Example using an in memory SQLite database:
import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from my_app.models import Base
@pytest.fixture(scope="session")
def engine():
engine = create_engine("sqlite:///:memory:")
Base.metadata.create_all(engine)
return engine
@pytest.fixture
def db_session(engine):
Session = sessionmaker(bind=engine)
session = Session()
yield session
session.rollback()
session.close()Test using the session:
def test_create_user(db_session):
user = User(email="alice@example.com")
db_session.add(user)
db_session.commit()
assert user.id is not NoneYou can also integrate this with your FastAPI app fixture, so your API tests use the same database session fixture.
Fixtures for API Client Tests
For HTTP API tests in FastAPI or Flask, you typically have a client fixture.
FastAPI example:
import pytest
from fastapi.testclient import TestClient
from my_app.main import create_app
@pytest.fixture
def client():
app = create_app(testing=True)
return TestClient(app)
def test_root(client):
response = client.get("/")
assert response.status_code == 200You can layer fixtures:
@pytest.fixture
def auth_token(client):
response = client.post("/login", json={"username": "alice", "password": "secret"})
return response.json()["access_token"]
def test_get_profile(client, auth_token):
headers = {"Authorization": f"Bearer {auth_token}"}
response = client.get("/me", headers=headers)
assert response.status_code == 200This reduces duplication of authentication logic across many tests.
Best Practices for Backend Fixtures
Some practical rules to keep your test suite maintainable:
- Keep fixtures small and focused
Each fixture should do one clear thing, for example "create app" or "create user". Compose them instead of making one giant fixture. - Avoid hidden magic
Prefer explicit fixtures in test function parameters. Useautouseonly when behavior should truly apply to everything. - Use clear, descriptive names
For exampledb_session,client,admin_user,normal_user,valid_token,expired_token. - Reset state between tests
Use function scoped fixtures and proper teardown so tests do not affect each other, for example clearing tables, caches, and environment variables. - Share common fixtures via conftest.py
Put cross cutting fixtures there, such as app, client, database, and configuration. - Mock external services
Use fixtures plusmonkeypatchor libraries likeresponsesto avoid calling real payment providers, email services, or external APIs.
By using fixtures well, your backend tests become cleaner, faster to write, and easier to maintain as your application grows.
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!