26.11. Performance Testing
Table of Contents
Why Performance Testing Matters
Performance testing checks how your backend behaves under load, not whether it is functionally correct. You want to know:
- How fast is it for users?
- How many users or requests can it handle?
- What breaks first, and where are the bottlenecks?
Functional tests answer “Does it work?”
Performance tests answer “Does it still work when it is busy?”
Typical goals:
- Detect slow endpoints and database queries.
- Set realistic SLAs (Service Level Agreements), for example “95% of requests under 300 ms”.
- Prevent regressions when you release new versions.
- Understand capacity: “This server handles about 500 requests per second.”
Key rule: Never performance test directly against production for experiments that can overload the system. Use a separate environment with the same configuration and similar data volume whenever possible.
Key Performance Metrics
For backend systems you usually care about four main classes of metrics.
Response Time and Latency
Response time (or latency) is how long it takes to handle one request. You will typically look at:
- Average latency, for example 120 ms
- Percentiles:
- P50: 50 percent of requests are faster than this (the “median”)
- P95: 95 percent are faster
- P99: 99 percent are faster (shows the worst tail)
Example:
| Metric | Meaning |
|---|---|
| P50 | Typical user experience |
| P95 | Experience during small spikes |
| P99 | Edge cases, worst situations |
Important: Always look at percentiles (P95, P99), not only averages. A low average can hide very slow outliers that users still feel.
Throughput
Throughput is how much work your system processes in a time unit, for example:
- Requests per second (RPS)
- Jobs per minute
- Database queries per second
Example:
If your API handles $600$ requests in $60$ seconds, throughput is:
$$\text{throughput} = \frac{600}{60} = 10 \text{ RPS}$$
Resource Usage
You also need to watch:
- CPU usage
- Memory usage
- Network usage (bandwidth, packets)
- Disk usage (IOPS, read/write MB/s)
- Database connections and pool usage
These help you answer:
- Is the CPU the bottleneck?
- Are we running out of memory?
- Is the database saturated?
Error Rate and Timeouts
Under load, errors can appear only when the system is stressed:
- HTTP 5xx errors (500, 502, 503, 504)
- Timeouts, for example client waits more than 5 seconds
- Connection errors, for example “connection refused”
You want:
- Error rate close to 0, even at target load.
- If errors start at 200 RPS, and your goal is 150 RPS, you are probably safe.
Types of Performance Tests
Different tests answer different questions. You rarely need only one type.
Load Testing
Question: “How does the system behave under expected normal and peak load?”
You choose a realistic number of users or requests, then see:
- Response times
- Error rates
- Resource usage
Example:
- Normal traffic: 50 RPS
- Daily peak: 120 RPS for 1 hour
You run a test that holds 120 RPS for 1 hour and check if the system stays healthy.
Stress Testing
Question: “What happens when we push the system beyond its limits?”
You increase load until you see:
- Error rates spike
- Response times explode
- CPU or database becomes saturated
Goal:
- Discover the breaking point, for example “at about 300 RPS, the database maxes out”.
- Observe how the system fails. Does it crash, or does it degrade gracefully?
Soak / Endurance Testing
Question: “Can the system handle expected load for a long time?”
You keep a realistic load for many hours, sometimes days, and watch for:
- Memory leaks (memory usage keeps growing)
- Resource leaks (open file descriptors, connections)
- Performance degradation over time
Example:
- Run 50 RPS for 24 hours and check that memory usage stabilizes instead of growing without bound.
Spike Testing
Question: “What if traffic suddenly jumps?”
You simulate sharp increases in traffic, for example:
- Jump from 10 RPS to 200 RPS in 5 seconds.
- Then drop back to 10 RPS.
Checks:
- Does the system handle it without many errors?
- How quickly does it recover?
- Are autoscaling rules fast enough?
Designing a Performance Test Plan
Before you start any tool, define a clear plan.
Define Goals and SLAs
Decide what “good enough” means. Examples:
- P95 latency < 300 ms for
/api/orders - Error rate < 0.5 percent at 100 RPS
- System should run at 70 percent CPU or less at peak load
Write these down. Your tests will check if you meet these conditions.
Understand Realistic Workloads
You need realistic traffic shapes, not only “one endpoint at full speed”.
Questions:
- Which endpoints are used most?
- What is a typical user flow? For example:
- Login
- List products
- View product
- Add to cart
- Checkout
- At peak time, how many concurrent users do you expect?
Example user behavior mix:
| Endpoint | Share of traffic |
|---|---|
| GET /products | 50% |
| GET /product/ID | 30% |
| POST /cart | 10% |
| POST /checkout | 10% |
Your test scenario should reflect this mix, not hammer a single endpoint that is rarely used.
Choose Scenarios
Typical scenarios:
- Single critical endpoint under load, for example
/api/search - Full user journey, for example login + browse + purchase
- Background tasks load, for example “process 1000 jobs per minute”
For an absolute beginner, it is usually helpful to:
- Start with 1 or 2 critical endpoints.
- Then add more realistic, multi-step user flows.
Popular Tools and Simple Examples
You can do performance testing with many tools. Most use the same idea: simulate many virtual users or requests and measure results.
Using `ab` (ApacheBench) for a Quick Test
ab is simple and often preinstalled on Linux.
Example: 1000 requests with up to 50 concurrent requests:
ab -n 1000 -c 50 https://example.com/api/itemsImportant flags:
-n 1000total number of requests-c 50number of concurrent requests
ab outputs statistics like:
- Requests per second
- Time per request
- Percentiles of response time
It is useful for quick, small experiments, but limited for complex scenarios.
Using `wrk` for More Realistic Load
wrk is a popular HTTP benchmarking tool.
Example: run for 30 seconds with 100 threads and 400 connections:
wrk -t100 -c400 -d30s https://example.com/api/itemsYou can also write Lua scripts to control request bodies or mix endpoints.
Using Locust for User Flows (Python Friendly)
Locust is written in Python and is great for modeling user behavior.
- Install:
pip install locust- Create
locustfile.py:
from locust import HttpUser, task, between
class WebsiteUser(HttpUser):
wait_time = between(1, 3) # seconds between tasks
@task(3) # weight 3
def list_products(self):
self.client.get("/products")
@task(1) # weight 1
def view_product(self):
self.client.get("/products/1")
@task
def add_to_cart(self):
self.client.post("/cart", json={"product_id": 1, "quantity": 1})- Run:
locust -f locustfile.py- Open the Locust web UI, for example
http://localhost:8089, and set:
- Number of users to simulate
- Spawn rate, how fast users appear
Locust will show:
- Current RPS
- Response time percentiles
- Failure rate
This is very useful for backend developers working in Python.
Running a Basic Load Test Step by Step
Here is a simple process you can follow for a single endpoint.
Step 1: Prepare the Environment
- Use a test or staging environment.
- Ensure configuration (CPU, memory, database) is similar to production.
- Seed the database with realistic data size, for example same number of users or orders.
Step 2: Choose a Target Endpoint and Load
Example:
- Endpoint:
GET /api/tasks - Target: 100 RPS
- Duration: 10 minutes
- SLA: P95 < 300 ms, error rate < 1 percent
Step 3: Configure the Tool
Example using Locust (simple version):
from locust import HttpUser, task, between
class TaskUser(HttpUser):
wait_time = between(0.1, 0.5)
@task
def list_tasks(self):
self.client.get("/api/tasks")Then:
- Run Locust.
- Set users so that throughput moves towards 100 RPS (you may need to increase or decrease).
Step 4: Monitor the System
While the test runs, watch:
- CPU usage on application server and database
- Memory usage
- Database metrics (queries per second, slow queries)
- Application logs for timeouts or errors
Use tools like:
top,htop,vmstaton Linux- Database dashboard (for PostgreSQL, for example
pg_stat_activity)
Step 5: Analyze the Results
Look at:
- P50, P95, P99 latency
- Error rate
- How metrics behave over time. If latency increases slowly, there might be resource saturation or garbage collector pressure.
Example interpretation:
- At 100 RPS:
- P95: 250 ms
- Error rate: 0.2 percent
- CPU: about 60 percent
- At 150 RPS:
- P95: 550 ms
- Error rate: 5 percent
- CPU: 90 percent, database connection pool maxed
Conclusion: Safe limit is around 100 RPS on this hardware. You also discovered that the database pool may be a bottleneck.
Interpreting and Acting on Results
Performance testing only helps if you act on what you learn.
Finding Bottlenecks
Common bottlenecks:
- Slow database queries (missing indexes, too many joins)
- N+1 queries in ORM code
- External API calls that are slow
- Blocking operations in async code
- Insufficient connection pools
You usually:
- Use application logs and metrics to find the slow part.
- Fix or optimize it.
- Run the same performance test again.
- Compare results.
This loop is very similar to unit testing, but focused on performance.
Regression Testing
When you change code or upgrade dependencies, performance can get worse.
To detect that, you can:
- Save previous test results as a baseline.
- After each significant change, run the same test.
- Compare P95, P99, and throughput.
Some teams automate this in CI/CD, for example:
- For every new release candidate, run a short performance test.
- Fail the pipeline if the endpoint is 30 percent slower than baseline.
Good Practices and Common Pitfalls
Good Practices
- Test early, not just before going live.
- Start with small loads, then step up gradually.
- Keep test scenarios under version control, for example commit Locust scripts to Git.
- Use metrics and logging from the beginning of the project so you can understand test results.
Common Pitfalls
- Testing only “hello world” endpoints instead of real logic.
- Using empty or tiny databases, which hides performance problems.
- Focusing only on throughput, not on user-facing latency.
- Running tests from your laptop on poor network and trusting raw numbers.
- Forgetting to reset the environment between tests, for example caches and data.
Connecting Performance Testing to Optimization
Performance testing is not optimization itself. It is the measuring tool.
Typical simple workflow:
- Run a test, discover that
/api/searchhas P95 = 1000 ms at 50 RPS. - Use logs and traces to see that the main time is spent in a slow SQL query.
- Add an index or change the query.
- Run the same test again.
- See P95 = 200 ms at 50 RPS.
Rule: Never optimize without measurement. Performance testing gives you data so you optimize the right part of the system.
In later chapters about database optimization, caching, and load balancing, these techniques will be your main tools to fix the problems that performance tests reveal.
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!