21.2. Docker Architecture
Table of Contents
Big Picture of Docker Architecture
Docker is built with a client server architecture. Understanding how its pieces fit together will make everything else about containers much clearer.
There are three core parts:
- Docker client
- Docker daemon (server)
- Registries (like Docker Hub)
Around these, there are additional pieces such as images, containers, networks, and volumes that you will use every day.
In this chapter we stay at the architecture level so you see how these parts talk to each other and where they run.
Docker Client
The Docker client is what you interact with directly. It is usually the docker command in your terminal.
Example commands:
docker ps
docker run nginx:latest
docker build -t myapp:1.0 .Key ideas:
- The client is a front end.
It does not run containers itself. It sends instructions to the Docker daemon. - The client can talk to:
- A local daemon on your machine.
- A remote daemon on another server.
- Multiple daemons, depending on configuration and context.
- Communication is done over:
- A Unix socket on Linux/macOS, for example
/var/run/docker.sock. - A named pipe on Windows, for example
//./pipe/docker_engine. - Or a TCP socket, for remote daemons, for example
tcp://192.168.1.10:2376.
You can think of the client as a REST API client for the Docker Engine API. It sends HTTP requests, receives HTTP responses, and prints human friendly output.
Example of pointing the client to a remote daemon:
export DOCKER_HOST=tcp://my-server:2376
docker ps
The docker command is just one client. Docker also provides:
docker composefor multi container applications.- SDKs for Go, Python, etc., that can also act as clients to the daemon.
Docker Daemon (Server)
The Docker daemon is the long running background process that actually manages:
- Images
- Containers
- Networks
- Volumes
On most systems the main daemon process is dockerd.
Responsibilities:
- Accept API requests from clients.
- Pull images from registries.
- Build images.
- Create, start, stop, and delete containers.
- Manage networking interfaces for containers.
- Manage storage, volumes, and image layers.
A simple lifecycle when you run:
docker run nginx:latest- Client sends a request to the daemon:
"Create a container from imagenginx:latestand start it." - Daemon checks if
nginx:latestis available locally. - If not, it pulls the image from a registry.
- Daemon creates a container:
- Sets up a filesystem from the image layers.
- Configures network interfaces, ports, and environment variables.
- Sets resource limits if requested.
- Daemon starts the container process.
- Daemon returns information to the client, which prints output.
The daemon can run:
- On your development laptop.
- On a remote Linux server.
- Inside a virtual machine in the cloud.
Multiple clients can talk to the same daemon at the same time.
The daemon has root level access to the host by default.
If you expose the Docker daemon API over TCP without proper authentication and TLS, anyone who can connect to it can fully control the host.
Never expose the daemon publicly without strong protection.
Docker Engine and Components
The full system that includes the daemon and its low level container runtime is often called Docker Engine.
From top to bottom there are several layers.
High level architecture:
- Docker Client
- Docker Engine API
- Docker Daemon (
dockerd) - Container runtime (for example
containerd,runc) - Linux kernel features (namespaces, cgroups, union file systems)
You usually do not work with the lower layers directly, but knowing they exist helps when debugging.
Docker Engine API
The Engine exposes a REST API. Every docker command turns into HTTP calls, for example:
GET /containers/jsonfordocker psPOST /containers/createfordocker createPOST /images/createfordocker pull
You can call this API directly from your own tools or backend services if you want to automate container operations.
Example, using curl to list containers on a Linux host:
curl --unix-socket /var/run/docker.sock http://localhost/containers/jsonContainer Runtime
The daemon does not talk directly to the kernel. Instead it uses lower level runtimes.
Typical stack:
dockerdtalks tocontainerd.containerdusesruncto create and run containers according to the OCI standard.
You rarely interact with these components directly in everyday backend work, but they explain how Docker can plug into other systems like Kubernetes.
Images and Layers
An image is an immutable blueprint from which containers are created.
Architecturally, images are made of layers. Each layer represents a filesystem change.
Example Dockerfile:
FROM python:3.12-slim # Layer 1: base system + Python
WORKDIR /app # Layer 2: metadata change
COPY requirements.txt . # Layer 3: adds file
RUN pip install -r requirements.txt # Layer 4: installs packages
COPY . . # Layer 5: application code
CMD ["python", "main.py"] # Metadata: default commandWhen you run:
docker build -t myapp:1.0 .The daemon:
- Reads the Dockerfile.
- Builds each instruction into a new layer.
- Stores layers in its local image store.
- Tags the final image as
myapp:1.0.
Layers are stored in a union filesystem so they appear as a single filesystem to the container, but underneath they are stacked.
Important consequences:
- Layer reuse
If two images share the same base image, that base layer is downloaded and stored only once. - Faster builds
If only the last layer changes, Docker reuses earlier layers from cache.
Example:
- Image A:
python:3.12-slim+ dependencies + app v1 - Image B:
python:3.12-slim+ same dependencies + app v2
The large base and dependency layers are shared. Only the final app code layer differs.
Important rule: Images are immutable.
After an image is built, you do not change it. You build a new image instead, usually with a new tag such as myapp:1.1.
This immutability is a core part of reliable deployments.
Containers as Running Instances
A container is a running instance of an image plus some runtime configuration.
Relationship:
- One image can have many containers.
- Containers are created, started, stopped, and deleted.
- The image remains unchanged.
When the daemon creates a container:
- It takes the image layers.
- Adds a thin writable layer on top.
- Starts the process defined by
CMDorENTRYPOINT. - Applies isolation:
- Namespaces for process IDs, network, mounts, etc.
- Control groups (cgroups) for CPU and memory limits.
From inside the container, the process sees:
- Its own filesystem, from the image.
- Its own process tree.
- Its own network interfaces and hostname.
From outside, you can inspect containers:
docker ps # list running containers
docker inspect ID # show full configuration and stateThink of a container as:
- Like a very lightweight virtual machine, but using the host kernel.
- Just a normal process on the host, with strong isolation.
Registries and Repositories
A registry is a server that stores and distributes images.
A repository is a collection of related image tags under a name in a registry, for example library/nginx.
Public registry example:
- Docker Hub at
hub.docker.com.
Private registry examples:
- GitHub Container Registry (
ghcr.io). - GitLab Container Registry.
- Self hosted Docker Registry.
Flow when you use docker pull:
- Client:
docker pull nginx:latest. - Daemon: Contacts the registry (Docker Hub by default).
- Registry: Authenticates the user if needed.
- Registry: Sends metadata and layers to the daemon.
- Daemon: Stores the image locally.
Flow when you use docker push:
- Daemon: Sends image layers to the registry.
- Registry: Stores layers and tags them.
Naming convention:
[registry-host/]namespace/repository[:tag]
Examples:
| Example image name | Meaning |
|---|---|
nginx | library/nginx:latest on default registry |
nginx:1.25 | nginx 1.25 tag on default registry |
myuser/myapp:1.0 | User myuser repository myapp on default registry |
ghcr.io/myorg/api:prod | Hosted on GitHub Container Registry for myorg |
Registries are critical in backend deployment because they are the bridge between your build pipeline and your production servers.
Storage: Volumes and Bind Mounts
Docker needs to store:
- Image layers.
- Container writable layers.
- Application data.
By default, the writable layer inside a container disappears when the container is removed. For persistent data you use:
- Volumes
Managed by Docker, usually stored under/var/lib/docker/volumes/...on the host. - Bind mounts
Directly mount a host directory or file into the container.
These are not separate daemon processes, but conceptually they form a storage layer in the architecture.
Example: named volume
docker volume create mydata
docker run -d \
-v mydata:/var/lib/postgresql/data \
--name mydb postgres:16Example: bind mount (useful in development)
docker run --rm -it \
-v $(pwd):/app \
-w /app \
python:3.12-slim python main.pyArchitectural idea:
- Containers are ephemeral.
- Volumes and host directories hold long lived data.
Networking and Communication
From an architecture perspective, Docker networking solves two main needs:
- Containers talking to each other.
- Containers exposing services to the outside world.
Docker daemon manages different network drivers. Three common ones:
| Network type | Default name | Typical use |
|---|---|---|
| bridge | bridge | Default for standalone containers |
| host | host | Container shares host network namespace |
| none | none | No network connectivity |
With user defined bridge networks, Docker also provides:
- Automatic DNS resolution by container name.
- Isolated network segments.
Example:
docker network create backend-net
docker run -d --name db --network backend-net postgres:16
docker run -d --name api --network backend-net my-api:1.0
Inside api container, connecting to db:5432 works because Docker provides an internal DNS entry.
To expose a container to the outside, the daemon sets up port mappings:
docker run -d -p 8080:80 --name web nginxHere:
- Port 80 inside the container is reachable on port 8080 on the host.
- The daemon configures iptables or an equivalent mechanism to route traffic.
Putting It All Together: End to End Example
Consider a typical backend workflow.
You:
- Write code and a
Dockerfilefor your FastAPI application. - Run
docker build -t myorg/myapi:1.0 . - Run tests, then
docker push myorg/myapi:1.0to a registry. - On a production server, you run
docker pull myorg/myapi:1.0. - You start the app with
docker run -d -p 80:8000 myorg/myapi:1.0.
Under the hood:
- The client sends
build,push,pull, andruncommands. - The daemon:
- Builds the image from a stack of layers.
- Stores the image locally.
- Communicates with the registry.
- Creates a container from the image.
- Sets up networking on port 80.
- Manages storage for container data.
Every time you use Docker in backend development, you are using this architecture: a client talking to a daemon, which orchestrates images, containers, networks, volumes, and registries.
Understanding this structure will help you when you:
- Configure remote deployments.
- Debug networking and storage issues.
- Secure the Docker environment on production servers.
- Work with more advanced tools like Docker Compose and Kubernetes, which build on the same concepts.
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!