19.2. Unit Testing
Table of Contents
Why Unit Testing Matters
Unit testing is about testing the smallest pieces of your code, usually individual functions or methods, in isolation. The goal is to prove that each “unit” behaves exactly as you expect.
You already saw why testing matters in the parent chapter. Here we focus specifically on unit tests, how they look, and how to think about them as a backend developer.
Unit tests will not test your full API, database, or external services. Those belong to other types of tests such as integration or end‑to‑end tests.
Key idea: A unit test checks a small piece of code in isolation, fast and deterministically.
It should not depend on a real database, network, filesystem, or other external systems.
What Is a “Unit”?
A "unit" is usually:
- A single function
- A single method of a class
- Occasionally a very small class
The exact definition depends on your project, but the spirit is the same: small, focused, and easy to reason about.
Examples of units
In backend code, good units to test include:
- A function that validates user input
- A function that calculates taxes or discounts
- A method that hashes a password string
- A function that parses configuration values from environment variables
Less ideal as a unit:
- “Create user in database and send email and log a message” all in one function
- “Handle the entire HTTP request” function that touches many layers
When a function does too many things, unit testing becomes harder. That is usually a sign you should refactor the code.
Characteristics of Good Unit Tests
Good unit tests generally have these properties:
| Property | Description |
|---|---|
| Fast | Run in milliseconds, so you can run them all the time |
| Isolated | Do not depend on database, network, or other tests |
| Deterministic | Always give the same result for the same code and input |
| Focused | Test one behavior or scenario at a time |
| Readable | Easy to understand what is being tested and why |
Rule: If your “unit” test is slow or flaky, it probably depends on something external. Consider mocking or refactoring.
Simple Unit Test Examples
You will typically write unit tests in a separate test file, for example:
- code file:
math_utils.py - test file:
test_math_utils.py
Below are examples in Python, since this course uses Python for backend development.
Example: Testing a pure function
math_utils.py:
def add(a: int, b: int) -> int:
return a + b
test_math_utils.py:
def test_add_two_positive_numbers():
result = add(2, 3)
assert result == 5
def test_add_with_zero():
result = add(7, 0)
assert result == 7Each test:
- Calls the function with specific inputs
- Asserts that the output is what you expect
There is no database, network, or filesystem involved. These are classic unit tests.
Example: Testing business logic
Imagine some backend business logic that calculates a discount:
discounts.py:
def calculate_discount(price: float, user_is_vip: bool) -> float:
if price < 0:
raise ValueError("Price cannot be negative")
discount_rate = 0.2 if user_is_vip else 0.05
return price * (1 - discount_rate)
test_discounts.py:
import math
def test_calculate_discount_for_vip_user():
result = calculate_discount(100.0, user_is_vip=True)
assert math.isclose(result, 80.0)
def test_calculate_discount_for_regular_user():
result = calculate_discount(100.0, user_is_vip=False)
assert math.isclose(result, 95.0)
def test_calculate_discount_raises_for_negative_price():
try:
calculate_discount(-10.0, user_is_vip=False)
assert False, "Expected ValueError"
except ValueError:
passYou test both normal cases (VIP and regular user) and error handling (negative price).
The AAA Pattern: Arrange, Act, Assert
Unit tests often follow the AAA pattern:
- Arrange: Set up data and objects
- Act: Call the function or method you want to test
- Assert: Check the outcome
Example in AAA style
def test_calculate_discount_for_vip_user():
# Arrange
price = 200.0
user_is_vip = True
# Act
result = calculate_discount(price, user_is_vip)
# Assert
assert result == 160.0Writing tests with AAA keeps them clear and structured.
Testing Edge Cases
Unit tests are especially good at covering edge cases. These are inputs that are rare or tricky.
Examples for backend logic:
- Empty strings
- Very large numbers
- Negative numbers
- Boundary values (exactly 0, exactly 1, exactly the maximum allowed)
- None values (when allowed)
- Unusual but valid characters (like unicode)
Example: Input validation helper
validators.py:
def is_valid_username(username: str) -> bool:
if not username:
return False
if len(username) < 3 or len(username) > 20:
return False
if not username.isalnum():
return False
return True
test_validators.py:
def test_valid_username():
assert is_valid_username("alice123") is True
def test_empty_username_is_invalid():
assert is_valid_username("") is False
def test_too_short_username_is_invalid():
assert is_valid_username("ab") is False
def test_too_long_username_is_invalid():
assert is_valid_username("a" * 21) is False
def test_username_with_special_characters_is_invalid():
assert is_valid_username("alice!") is FalseThese tests describe the rules of what is valid or invalid, and serve as executable documentation.
Isolating Units with Simple Stubs or Mocks
Even in unit tests, sometimes a function depends on something external. For example:
- A clock or current time
- Random numbers
- Configuration from the environment
Even these can make tests flaky or hard to reproduce.
Example: Function that uses “now”
time_utils.py:
from datetime import datetime, timedelta, timezone
def is_token_expired(issued_at: datetime, ttl_seconds: int) -> bool:
now = datetime.now(timezone.utc)
return now > issued_at + timedelta(seconds=ttl_seconds)
This is tricky to unit test because datetime.now changes all the time.
A simple pattern to improve testability is dependency injection: pass in what you need.
from datetime import datetime, timedelta, timezone
from typing import Callable
def is_token_expired(
issued_at: datetime,
ttl_seconds: int,
now_func: Callable[[], datetime] = lambda: datetime.now(timezone.utc),
) -> bool:
now = now_func()
return now > issued_at + timedelta(seconds=ttl_seconds)Now you can test with a "fake" clock:
test_time_utils.py:
from datetime import datetime, timedelta, timezone
def test_token_not_expired_yet():
issued_at = datetime(2023, 1, 1, tzinfo=timezone.utc)
ttl = 60
def fake_now():
return issued_at + timedelta(seconds=30)
assert is_token_expired(issued_at, ttl, now_func=fake_now) is False
def test_token_expired():
issued_at = datetime(2023, 1, 1, tzinfo=timezone.utc)
ttl = 60
def fake_now():
return issued_at + timedelta(seconds=120)
assert is_token_expired(issued_at, ttl, now_func=fake_now) is TrueYou did not touch a real clock. The test is deterministic and fast.
Pure Functions vs Functions with Side Effects
Unit testing is easiest when you have pure functions:
- Same input, same output
- No side effects
Functions with side effects are harder to test:
- They write to a database
- They send an email
- They make an HTTP call
For unit tests, there are two common strategies:
- Refactor to separate pure logic from side effects
- Mock the side effect in tests, so you do not actually perform it
Example: Refactor to test pure logic
Bad design in one function:
def register_user(email: str, password: str):
# 1. Validate email and password
# 2. Hash password
# 3. Insert into database
# 4. Send welcome email
...Better design, splitting logic:
def validate_registration(email: str, password: str) -> None:
# only validate, no side effects
...
def hash_password(password: str) -> str:
...
def register_user_in_db(email: str, password_hash: str):
...
def send_welcome_email(email: str):
...
def register_user(email: str, password: str):
validate_registration(email, password)
password_hash = hash_password(password)
user = register_user_in_db(email, password_hash)
send_welcome_email(email)
return user
Then you can unit test validate_registration and hash_password easily, while register_user may need mocking or be covered by higher-level tests.
When Is a Test a Unit Test vs Integration Test?
Sometimes it is not obvious.
| Scenario | Type of test (typically) |
|---|---|
| Test a pure function that adds numbers | Unit test |
| Test a function that parses a JSON string | Unit test |
| Test a function that reads a real file | Integration / system detail |
| Test a repository function that hits a real DB | Integration test |
| Test an API endpoint using a real HTTP server | Integration or end‑to‑end test |
If your test touches:
- Real network
- Real database
- Real filesystem
it is usually not a unit test anymore.
The parent chapter and later chapters will cover integration and API testing in more detail, so here we focus mainly on the pure, isolated case.
Naming and Organizing Unit Tests
Clear structure makes your test suite maintainable.
File and folder structure
A typical Python project might have:
app/
services/
discounts.py
validators.py
tests/
unit/
test_discounts.py
test_validators.py
integration/
test_api_endpoints.pyYou separate unit and integration tests into different folders.
Naming tests
Good names describe the behavior, not just the function:
| Bad name | Better name |
|---|---|
test_discount_vip | test_calculate_discount_for_vip_user |
test_invalid | test_is_valid_username_rejects_empty_string |
test_edge | test_calculate_discount_raises_for_negative_price |
A good test name reads like a sentence and tells you what went wrong if it fails.
What to Unit Test First in a Backend Project
As a backend beginner, focus your unit tests on:
- Business rules
- Discount calculation
- Free shipping logic
- Inventory checks
- Input validation logic
- Email and password validation
- Length limits
- Allowed characters
- Utility functions
- String helpers
- Timestamp / token helpers (with injected time)
These parts often have tricky rules and many edge cases. Unit tests are perfect here.
You can cover:
- Database access with integration tests
- Full endpoints with API tests
So do not worry if every function is not unit tested. Target the parts that benefit most.
Common Mistakes in Unit Testing
Avoid these typical problems:
- Testing implementation details instead of behavior
- Example: Asserting that a function calls another internal function, instead of checking the final result.
- Behavior is more stable than implementation.
- Writing tests that are too big
- Testing half of your application in a single test.
- Split into smaller behavioral checks.
- Relying on external systems
- Real databases, external APIs, actual file IO, real current time.
- Use pure logic, dependency injection, or mocking for unit tests.
- Not running tests often
- Unit tests are meant to be run after small code changes.
- If they are slow, they are likely not true unit tests.
Summary
Unit testing is about:
- Testing small, isolated pieces of code
- Keeping tests fast, deterministic, and focused
- Covering normal cases and edge cases
- Treating tests as executable documentation of your business rules
As a backend developer, think of unit tests as the foundation of your test suite. They give you confidence that your core logic behaves correctly, which then supports higher-level integration and API tests later in the course.
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!