26.9. Vertical Scaling
Table of Contents
Understanding Vertical Scaling
Vertical scaling is about making a single server more powerful so it can handle more work. Instead of adding more machines, you upgrade the one you already have.
In this chapter you will see what vertical scaling is, how it compares to horizontal scaling, when it works well, and what limits it in real applications.
What Is Vertical Scaling?
Vertical scaling means increasing the capacity of one node.
Typical ways to scale vertically:
- Add more CPU cores
- Use faster CPUs
- Add more RAM
- Use faster disks (for example move from HDD to SSD, or to faster SSDs)
- Use better network hardware
In cloud environments, vertical scaling usually means:
- Switching from a small instance type to a larger one, for example:
t3.small→t3.largedb.t3.micro→db.m6g.large- Changing configuration of a managed database to use more vCPUs and memory
You still have one application instance or one database instance, only bigger.
Vertical vs Horizontal Scaling
You learn about horizontal scaling in another chapter. Here is the focused comparison:
| Aspect | Vertical scaling | Horizontal scaling |
|---|---|---|
| Basic idea | Make one machine bigger | Add more machines |
| Number of instances | Stays 1 | Grows (2, 3, 10, 100, …) |
| Implementation effort | Usually simple (change instance size) | Requires more architecture work |
| Typical limits | Hardware limit of one machine | Coordination and network complexity |
| Good for | Early growth, databases, simple apps | Large scale, high availability, big traffic |
| Downtime risk | Often requires restart or maintenance window | New nodes can be added with less disruption |
| Cost behavior | Often grows nonlinearly with size | More linear, but adds operational overhead |
Vertical scaling is usually the first step when your application hits resource limits, especially for:
- Databases
- Caches
- Simple monolithic applications
When Vertical Scaling Works Well
Vertical scaling is very effective in several common situations.
1. Early Stage or Simple Architecture
When you have:
- One API server
- One database
- Possibly one cache
you can often handle a lot more load by just:
- Increasing CPU and RAM for the API server
- Upgrading the database instance class
- Moving to SSD if you use spinning disks
Example:
- Your task management API is slow under load
- CPU usage on the server is at 90%, memory is fine
- You move from 2 CPU cores to 4 CPU cores
- The same code now serves more requests per second
No code changes, no new infrastructure components.
2. CPU-Bound Workloads
If your backend spends most time doing CPU work, for example:
- Encoding images
- Encrypting / decrypting data
- Complex calculations
- Heavy JSON serialization
then more CPU and better single-core performance can help a lot.
Example:
- A report generator that takes ~45 seconds on a 2-core server
- On a 4-core server with faster CPU, the same report may complete in ~20 seconds
3. Memory-Bound Workloads
Some workloads are limited by RAM:
- Large in-memory caches
- Big queries that need to sort or join lots of data
- Many concurrent processes or threads
If processes are constantly killed by the OS because of out-of-memory, or your database is swapping to disk, adding RAM can dramatically increase performance.
Example:
- PostgreSQL with 1 GB RAM:
- Frequently hits disk
- Slow queries under load
- Upgrade to 8 GB RAM:
- Working set fits in RAM
- Queries become much faster without any code changes
4. Databases and State
Databases are often the hardest component to scale horizontally. Vertical scaling is a natural first strategy:
- Increase CPU for faster query execution
- Increase RAM so more data stays in buffer cache
- Move to faster disks to reduce I/O latency
For many products databases can run for a long time on a single powerful machine before horizontal scaling is necessary.
Practical Example: Scaling a Simple API
Imagine a FastAPI application running on one server.
Initial server:
- 2 vCPUs
- 4 GB RAM
- Basic SSD
Traffic grows, and you see:
- 95% CPU usage during peak hours
- Response times increase from 100 ms to 800 ms
- Error rate grows because of timeouts
Without changing your code you:
- Upgrade to 4 vCPUs
- Upgrade to 8 GB RAM
After the upgrade:
- CPU usage drops to around 50% at peak
- Response time goes back to 120 ms
- Error rate drops significantly
You did vertical scaling. The process was:
- Observe metrics
- Identify the bottleneck (CPU in this case)
- Increase the relevant resource
- Observe again
This pattern is common early in a project.
How to Decide Whether to Scale Vertically
You should always base scaling decisions on measurements, not guesses.
Useful metrics:
| Component | Metric examples | Vertical scaling signal |
|---|---|---|
| CPU | Average CPU usage, per-core usage | Sustained > 70–80% for long periods |
| Memory | Memory usage, swap usage, OOM errors | Frequent swapping, OOM kills, high page faults |
| Disk | Disk I/O wait, IOPS, disk latency | High I/O wait time, slow reads/writes |
| Network | Network throughput, dropped packets | Constantly at or near NIC limits |
| Database | Buffer cache hit ratio, slow queries | Low cache hit ratio, heavy I/O, CPU-bound queries |
A simple decision process:
- Identify where the bottleneck is
- Check if a bigger instance can reduce that bottleneck
- Estimate cost vs. benefit
- Plan and execute the upgrade, including a rollback plan
Important rule: Always profile and measure first, then scale. Do not scale vertically based on intuition alone.
Benefits of Vertical Scaling
Vertical scaling has several strong advantages:
Simplicity
- No need to add load balancers
- No need for complex stateless architectures
- Fewer moving parts, easier to reason about
Fast to Apply
In many cloud providers:
- Stop instance
- Choose bigger instance type
- Start instance
Managed databases often offer a one-click or automated upscale.
No Code Changes Required
Most of the time, you get benefits just by:
- Increasing CPU and memory
- Ensuring your application uses the hardware correctly (for example right number of worker processes)
Your application architecture can remain the same.
Good for Single-Node Stateful Systems
For:
- Databases
- Message queues
- Caches
vertical scaling avoids the complexity of clustering or sharding for as long as possible.
Limits of Vertical Scaling
Vertical scaling is powerful, but it has hard and soft limits.
Hard Limits
You cannot keep growing a single machine forever.
Examples:
- Maximum vCPUs for an instance type, for example 96 or 128
- Maximum RAM on a physical host
- Maximum network bandwidth per instance
At some point, there is simply no bigger machine.
Diminishing Returns
Even before you hit hard limits, returns can become worse.
Reasons:
- Contention on shared resources inside the machine
- Operating system overhead
- Some workloads do not parallelize well
For example:
- Adding CPUs might not help if your code is mostly single-threaded
- Adding RAM might not help if your working set already fits in memory
Downtime Risk
Changing instance size often requires:
- Reboot
- Short downtime for cutover to a new instance
For production systems, this means:
- Maintenance windows
- Careful preparation
- Potential customer impact
You can reduce downtime with techniques like blue/green deployments, but that is more complex.
Cost Behavior
Vertical scaling often has non-linear cost:
- 2x bigger instance may cost more than 2x the price
- Very large instances can be disproportionately expensive
Example:
| Instance type | vCPUs | RAM | Price (relative) |
|---|---|---|---|
| Small | 2 | 4GB | 1x |
| Medium | 4 | 8GB | 2.4x |
| Large | 8 | 16GB | 5.5x |
So 4x capacity might cost more than 4x money.
Single Point of Failure
One big machine is still one machine.
If that machine:
- Crashes
- Has hardware failure
- Has a network issue
your whole system goes down.
Horizontal scaling helps with high availability. Vertical scaling alone cannot.
Important statement: Vertical scaling alone cannot give high availability. You still have a single point of failure.
Vertical Scaling and Performance Types
You learned about CPU-bound and I/O-bound work in another chapter. Vertical scaling interacts with them in different ways.
CPU-Bound Work
Vertical scaling helps by:
- More CPU cores
- Faster single-core performance
Example:
- A synchronous image processing endpoint
- Each request uses 1 core fully for 500 ms
- With 2 cores, you can handle ~4 such requests per second
- With 8 cores, you can handle ~16 such requests per second (in ideal conditions)
If your application server can use multiple processes or threads, more cores usually mean more throughput.
I/O-Bound Work
Vertical scaling helps mostly by:
- Faster disks for I/O-bound databases or file systems
- More RAM for caching data and reducing disk access
- Better network interface for network-heavy workloads
Example:
- PostgreSQL doing many disk reads
- On slow HDD, each disk read is slow
- Moving to SSD can reduce read latency by a factor of 10 or more
Here, even if CPU is not the limit, better hardware makes each I/O operation faster.
How to Scale Vertically in Practice
Even though every provider is different, there are common patterns.
Scaling an Application Server
Steps usually include:
- Check metrics
- CPU, memory, load average, response times
- Choose a bigger instance
- More vCPUs
- More RAM
- Plan the upgrade
- Off-peak time if you expect downtime
- Backup important data (logs, configurations)
- Upgrade
- Resize instance or create a new bigger one and move traffic
- Verify
- Check metrics after upgrade
- Run smoke tests on critical endpoints
You might also adjust application settings:
- Number of worker processes for Gunicorn / Uvicorn
- Database connection pool size
- Thread pools in background workers
Scaling a Database Vertically
Typical steps:
- Analyze database performance
- Slow queries
- Buffer cache hit ratio
- CPU and disk usage
- Try optimizations first
- Indexes
- Query optimization
- Configuration tuning
- If still constrained, increase instance size
- Monitor after upgrade
- Verify that performance actually improved
It is common to:
- Combine vertical scaling with index and query improvements
- Use more RAM to allow bigger caches
Combining Vertical and Horizontal Scaling
Vertical and horizontal scaling are not enemies. You often use both over time.
Typical growth path:
- Small instance, simple app
- Vertically scale:
- Bigger app server
- Bigger database instance
- When vertical scaling becomes too expensive or reaches limits:
- Add more app servers behind a load balancer
- Use read replicas for the database
- Move some responsibilities to other services
Vertical scaling often comes first because it is:
- Cheaper to implement at the engineering level
- Faster to apply
- Good enough for many use cases
Later, you add horizontal scaling for:
- High availability
- Better fault tolerance
- Very high traffic
Rules of Thumb for Vertical Scaling
You can treat these as practical guidelines.
Rules of thumb:
- Use vertical scaling first for simple systems until costs or technical limits make it unreasonable.
- Always measure bottlenecks before scaling, and validate after scaling.
- Do not rely on vertical scaling for high availability, use redundancy and horizontal strategies for that.
- Optimize software and queries before or alongside buying bigger hardware.
Applied examples:
- If CPU is always at 90% and response times are bad, increase CPU or number of cores.
- If memory is always full and the system swaps or kills processes, add RAM.
- If database I/O wait is high, move from HDD to SSD or to faster SSDs and consider more RAM.
- If a bigger instance is significantly more expensive than adding another small instance plus a load balancer, consider transitioning to horizontal scaling.
Summary
Vertical scaling is about making your existing server more powerful by upgrading CPU, memory, disk, or network. It is:
- Very simple to implement
- Great for early stages and for databases
- Limited by hardware maximums, cost growth, and single point of failure
As a backend developer you should:
- Recognize when vertical scaling is appropriate
- Know how to read basic resource metrics
- Plan and execute vertical upgrades safely
- Understand that at some scale you will need horizontal strategies too
You will see how vertical scaling compares to horizontal scaling and how to design for large scale in the surrounding chapters on performance and scalability.
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!