19.5. pytest
Table of Contents
Why pytest?
pytest is a popular Python testing framework that makes tests:
- Short to write
- Easy to read
- Powerful to extend
You will use pytest in almost every modern Python backend project, especially with FastAPI and database code.
Key ideas:
- Tests are just Python functions.
- You do not need to write classes or inherit from anything.
- pytest automatically finds and runs tests based on file and function names.
- pytest integrates nicely with fixtures, mocks, coverage tools, and CI.
Rule: In this course, always use pytest as the main test runner for Python backend projects.
In this chapter you will learn how to:
- Install and run pytest
- Structure test files
- Write basic and parametrized tests
- Use assertions effectively
- Use basic fixtures
- Organize tests for a backend project
Installing pytest
Use pip to install pytest into your virtual environment.
pip install pytestCheck that pytest is installed:
pytest --versionYou should see something like:
pytest 8.3.0
In many real projects, pytest will be added to your requirements.txt or pyproject.toml under development dependencies.
Example requirements.txt snippet:
fastapi
uvicorn
sqlalchemy
pytest
pytest-asyncioLater, when someone runs:
pip install -r requirements.txtpytest will be installed as well.
How pytest discovers tests
pytest looks for tests using a simple naming convention.
By default, pytest:
- Searches for files named:
test_.pyor_test.py- Inside those files, it runs functions named:
test_*
So:
| File name | Function name | Will pytest run it? |
|---|---|---|
test_math.py | test_add | Yes |
math_test.py | test_add | Yes |
math.py | test_add | No (file name wrong) |
test_math.py | add | No (function name wrong) |
Example structure:
project/
app/
main.py
tests/
test_example.py
tests/test_example.py:
def test_example():
assert 1 + 1 == 2Run:
pytest
pytest will find tests/test_example.py, then find test_example and run it.
You usually do not have to list each test file separately. Just run pytest at the project root and let it auto-discover.
Running tests with pytest
The most common commands:
# Run all tests
pytest
# Run tests with more verbose output
pytest -v
# Run tests in a specific file
pytest tests/test_math.py
# Run a specific test function
pytest tests/test_math.py::test_add
# Show print() output
pytest -s
# Stop after first failure
pytest -xExample:
pytest -v tests/test_math.pyOutput (simplified):
==================== test session starts ====================
collected 2 items
tests/test_math.py::test_add PASSED [ 50%]
tests/test_math.py::test_subtract PASSED [100%]
==================== 2 passed in 0.02s ======================Use this pattern often when developing:
- Edit code or tests.
- Run
pytest -qorpytest -q tests/test_something.pyto get quick feedback.
Writing your first pytest tests
A simple test
Create tests/test_math.py:
def add(a, b):
return a + b
def test_add_positive_numbers():
result = add(2, 3)
assert result == 5Run:
pytest -v tests/test_math.pyKey points:
- The test is a normal Python function.
- The test body uses simple Python code.
- The important part is the
assertstatement.
pytest will run the test and interpret any failing assert as a test failure.
Multiple tests in a file
def add(a, b):
return a + b
def subtract(a, b):
return a - b
def test_add_positive_numbers():
assert add(2, 3) == 5
def test_add_negative_numbers():
assert add(-2, -3) == -5
def test_subtract_result_positive():
assert subtract(5, 3) == 2
def test_subtract_result_negative():
assert subtract(3, 5) == -2
Each test_* function is a separate test. If one fails, the others can still pass.
Assertions in pytest
Basic assertions
pytest uses the built-in Python assert keyword, but it gives better error messages.
def test_assertion_examples():
# equality
assert 1 + 1 == 2
# inequality
assert 3 != 4
# truthy / falsy
assert "backend"
assert not ""
# membership
assert "a" in "backend"
assert 2 in [1, 2, 3]
# type checking
value = 10
assert isinstance(value, int)If an assertion fails, pytest shows why.
def test_fail():
assert 1 + 1 == 3Output:
> assert 1 + 1 == 3
E assert 2 == 3
E + where 2 = (1 + 1)This detail helps you debug quickly.
Rule: In pytest tests, always use simple assert statements instead of unittest style methods like self.assertEqual.
Checking exceptions
Sometimes you expect your code to raise an error.
Use pytest.raises as a context manager:
import pytest
def divide(a, b):
if b == 0:
raise ValueError("division by zero")
return a / b
def test_divide_by_zero():
with pytest.raises(ValueError) as exc_info:
divide(10, 0)
assert "division by zero" in str(exc_info.value)This checks that:
- A
ValueErroris raised. - The error message contains "division by zero".
Parametrized tests
Often you want to test the same function with many input/output pairs. Instead of writing many separate test functions, you can parametrize a single test.
Example without parametrization:
def double(x):
return x * 2
def test_double_1():
assert double(1) == 2
def test_double_2():
assert double(2) == 4
def test_double_3():
assert double(3) == 6With parametrization:
import pytest
def double(x):
return x * 2
@pytest.mark.parametrize(
"input_value, expected",
[
(1, 2),
(2, 4),
(3, 6),
(-1, -2),
],
)
def test_double(input_value, expected):
assert double(input_value) == expected
pytest will run test_double four times, with different arguments.
This is very useful in backend tests for:
- Valid and invalid inputs.
- Different HTTP status expectations.
- Different combinations of query parameters.
Example for HTTP-like logic:
import pytest
def is_valid_status(code: int) -> bool:
return 200 <= code < 300
@pytest.mark.parametrize(
"code, expected",
[
(200, True),
(201, True),
(204, True),
(301, False),
(400, False),
(500, False),
],
)
def test_is_valid_status(code, expected):
assert is_valid_status(code) == expectedUsing fixtures (basic idea)
Fixtures are special functions that provide reusable data or setup for tests, such as:
- A temporary directory
- A database connection
- A test user
- A test HTTP client
Here is a very simple example:
import pytest
def connect_to_fake_db():
return {"connected": True}
@pytest.fixture
def db():
# Setup part
connection = connect_to_fake_db()
yield connection
# Teardown part could go here (for example close connection)
def test_db_connection(db):
assert db["connected"] is TrueWhat happens:
- pytest sees
@pytest.fixtureondb, sodbbecomes a fixture. - The
test_db_connectionfunction has a parameterdb. - pytest calls the
dbfixture before the test, gets the value fromyield, and passes it into the test function.
In later chapters you will see more realistic fixtures, for example:
- A FastAPI test client fixture.
- A database session fixture.
- A fixture that clears a Redis cache between tests.
For now, remember:
Rule: If a test function has a parameter name that matches a fixture, pytest automatically provides that fixture.
Test structure and naming
Test directory structure
A common layout in backend projects:
project/
app/
__init__.py
main.py
models.py
services/
users.py
tests/
__init__.py
test_main.py
test_users.py
services/
test_users_service.py- Put all tests into a
testsdirectory at the project root. - Use test file names that mirror your modules.
Example mapping:
| Code file | Test file |
|---|---|
app/main.py | tests/test_main.py |
app/services/users.py | tests/services/test_users.py |
app/models.py | tests/test_models.py |
This makes it easy to find tests for a given piece of code.
Naming tests
Use clear, descriptive names that say what should happen.
Bad:
def test_1():
...Better:
def test_create_user_stores_hashed_password():
...
def test_create_user_rejects_duplicate_email():
...Common patterns:
test_<function>_<condition>_<expected_result>test_<route>_<status_code>_<condition>
Examples:
def test_register_user_returns_201_on_success():
...
def test_login_returns_401_for_invalid_credentials():
...Basic configuration with pytest.ini
You can configure pytest behavior with a pytest.ini file in the project root.
Simple example:
# pytest.ini
[pytest]
minversion = 8.0
addopts = -ra -q
testpaths =
testsExplanation:
minversion: minimum pytest version required.addopts: default command line options.-rashows a summary for skipped, failed, etc.-qruns in quiet mode.testpaths: default directories to search for tests.
In real backend projects you might also add markers or asyncio settings here, but that belongs in later chapters.
Using pytest for backend-style code
Here is a small, backend-flavored example to connect everything.
Imagine you have a simple authentication service:
app/auth.py:
from hashlib import sha256
def hash_password(password: str) -> str:
return sha256(password.encode("utf-8")).hexdigest()
def check_password(password: str, password_hash: str) -> bool:
return hash_password(password) == password_hashYou write tests like this:
tests/test_auth.py:
from app.auth import hash_password, check_password
def test_hash_password_returns_same_length_for_same_algorithm():
hash1 = hash_password("secret1")
hash2 = hash_password("secret2")
assert len(hash1) == len(hash2)
def test_check_password_returns_true_for_correct_password():
password = "mysecret"
password_hash = hash_password(password)
assert check_password("mysecret", password_hash) is True
def test_check_password_returns_false_for_wrong_password():
password_hash = hash_password("correct")
assert check_password("wrong", password_hash) is FalseRun:
pytest -vYou will see three tests executed. This is the same pattern you will use later when testing:
- FastAPI routes
- Database access functions
- Authentication flows
- Business logic services
Summary
In this chapter you learned the basics of pytest:
- Install via
pip install pytest. - pytest auto-discovers tests in
test_.pyand_test.pyfiles. - Tests are simple functions named
test_*. - Use plain
assertfor checks. - Use
pytest.raisesto test exceptions. - Parametrize tests with
@pytest.mark.parametrize. - Use fixtures to share setup code.
- Organize tests in a
testsdirectory mirroring your app structure. - Configure pytest with
pytest.iniif needed.
You will apply these foundations in later chapters when testing FastAPI apps, databases, and authentication logic.
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!