27.10. Real-Time Applications
Table of Contents
Understanding Real-Time Applications
Real-time applications are systems where users see updates almost immediately after something happens, without needing to refresh the page or send a new request manually.
In a classic request-response model, the client asks for data, the server answers, and that is it. In a real-time application, the server can also push new data to the client as soon as it is available.
Common examples:
- Chat applications (Slack, WhatsApp Web)
- Live dashboards and analytics (stock prices, server metrics)
- Collaborative tools (Google Docs, Figma)
- Online games and multiplayer boards
- Notifications and activity feeds
- Live location tracking (delivery apps, maps)
Real-time does not mean “literally instant.” It normally means “fast enough that users perceive it as immediate,” usually within a few hundred milliseconds.
Key idea: A real-time app is one where the server can deliver new data to the client as soon as it exists, without the client asking for it each time.
Patterns for Real-Time Communication
There are several ways to build real-time features on top of HTTP and related technologies.
1. Polling
Polling is the simplest strategy. The client asks the server for new data every few seconds.
Example:
- Every 2 seconds, the browser sends:
GET /notifications - The server returns any new notifications, or an empty list
Pseudocode in JavaScript:
async function pollNotifications() {
const response = await fetch('/notifications');
const data = await response.json();
renderNotifications(data);
setTimeout(pollNotifications, 2000); // repeat after 2 seconds
}
pollNotifications();Pros:
- Very easy to implement
- Works with any backend that supports HTTP
Cons:
- More requests than necessary
- There can be up to the polling interval as a delay
- Wastes resources when nothing changes
Polling is acceptable when:
- Updates are not very frequent
- A delay of a few seconds is fine
- You want a simple solution with no special protocols
2. Long Polling
Long polling keeps the same idea as polling, but reduces needless requests.
Flow:
- Client sends
GET /events. - Server:
- If there is an event, returns it immediately.
- If there is no event yet, keeps the request open for some time (for example 30 seconds).
- If a new event appears while the request is open, the server returns it at once.
- If no event appears in 30 seconds, the server returns an empty response or timeout.
- Client immediately sends another
GET /events.
This way, during quiet periods, there is at most one open request instead of many idle requests.
Pros:
- Works over normal HTTP
- Near real-time updates
- Supported even by very old browsers
Cons:
- Still uses many requests over time
- Harder to scale, many hanging connections
- More complex server logic than simple polling
3. Server-Sent Events (SSE)
SSE uses a single long-lived HTTP connection from client to server, where the server streams events as text.
Characteristics:
- Client connects with
GETto an endpoint like/events. - Server responds with headers:
Content-Type: text/event-stream
Cache-Control: no-cache
Connection: keep-alive- Then writes events in a special text format:
event: message
data: {"text": "Hello"}
event: count
data: 42- The client receives each event as it arrives.
Client example (browser):
const source = new EventSource('/events');
source.onmessage = (event) => {
const data = JSON.parse(event.data);
console.log('New message:', data);
};
source.addEventListener('count', (event) => {
console.log('Count event', event.data);
});Pros:
- Very simple in the browser (built-in
EventSource) - HTTP based, easy to integrate
- Works well for server to client streams (one way)
Cons:
- Browser to server is still normal HTTP requests, not a live channel
- Only supports text streaming, not binary
- Some environments do not support SSE well (for example some proxies, older browsers)
SSE is great for:
- Live dashboards and metrics
- Notifications
- Streaming logs
- Market or sports scores where the server broadcasts data
4. WebSockets
WebSockets provide a bidirectional connection between client and server.
- Connection starts from an HTTP request with an upgrade header.
- If the server accepts, both sides switch to the WebSocket protocol.
- After that, both client and server can send messages at any time.
This enables:
- Two-way chat
- Multiplayer games
- Collaborative editing
- Real-time control panels
The difference from SSE:
| Feature | SSE | WebSockets |
|---|---|---|
| Direction | Server to client only | Both client and server |
| Transport | HTTP text stream | WebSocket protocol on top of TCP |
| Browser API | EventSource | WebSocket |
| Complexity | Simple | More complex |
| Good for | Notifications, feeds | Chat, games, collaborative apps |
Real-Time vs REST APIs
REST APIs:
- Stateless HTTP requests.
- Each request is independent.
- Client decides when to ask for data.
- Easy to cache and scale.
Real-time channels (WebSockets or SSE):
- Long-lived connections.
- Server can push updates at any time.
- Both sides can keep context in memory during the connection.
- Harder to cache and distribute, but more interactive.
In real applications you often use both:
- REST for “normal” operations: sign up, login, CRUD for data.
- Real-time channels for live updates: “someone changed this document,” “new chat messages,” “new orders arrived.”
Example flow in a chat app:
- User sends a message:
POST /messages(REST). - Server saves it to the database.
- Server publishes “new message” event to a message broker.
- A WebSocket server receives the event.
- WebSocket server sends the new message to all connected clients in that chat room.
This keeps your API simple and still gives real-time UX.
Core Design Challenges in Real-Time Apps
Real-time apps bring new challenges that are less visible in plain REST APIs.
Connection Management
You must handle:
- Many open connections per server.
- Detect when clients disconnect.
- Reconnect clients after network failures.
Typical patterns:
- Use ping or heartbeat messages every few seconds.
- On missed heartbeats, close the connection.
- Client retries with exponential backoff.
Example heartbeat flow:
- Every 20 seconds, server sends:
{ "type": "ping" }. - Client responds with
{ "type": "pong" }. - If server does not receive
pongafter some time, it closes the connection.
Identifying Users and Sessions
You still need authentication and authorization, but now the connection lives a long time.
Common approaches:
- Client includes an access token in the connection request.
- Server validates token and attaches user id to the connection context.
- For each message, you can know which user sent it.
Example WebSocket URL with token in query (simplified):
wss://api.example.com/ws/chat?token=abc123
Better options are usually:
- Send token in a header during the upgrade or handshake.
- Or send an authenticate message as the first message.
Never trust data inside the message alone. Validate tokens during connection and, for long-lived connections, consider revalidating if tokens expire.
Rooms, Topics, and Subscriptions
Real-time apps often have the idea of “who should receive which messages.”
Common patterns:
- Rooms or channels in chat:
room:123,room:general - Topics in pub/sub systems:
orders.created,notifications.user.42 - Subscriptions: client subscribes to a subset of data
Examples:
- Client subscribes to live updates for
order_id = 10. - Admin dashboard subscribes to all new orders.
- User subscribes only to their notifications.
To support this, your server keeps an in-memory mapping:
- Room name → list of connections
- Topic name → list of connections
- User id → list of connections
When a new event arrives, you look up the correct group and send messages only to those connections.
Ordering and Idempotency
Messages may arrive:
- Out of order
- Duplicated
- Missing (for example if connection drops)
To handle this safely:
- Each message should have a unique id or sequence number.
- The client can ignore duplicates.
- The client can detect missing sequence numbers and request history from a REST API.
Example:
- Events for document edits have
versionnumbers: 1, 2, 3, ... - Client sees version 1, then receives version 3.
- It knows version 2 is missing, so it can request a full document from the REST API.
Scaling Real-Time Connections
One server process can usually handle many open connections, especially with asynchronous frameworks. But for large systems you need multiple servers.
Problem:
- User A is connected to Server 1.
- User B is connected to Server 2.
- User A sends a message to B.
- How does Server 1 tell Server 2?
Solution:
- Use a message broker or pub/sub system such as Redis, Kafka, or a managed service.
- Each server subscribes to relevant channels (for example
user.42.notifications). - When Server 1 receives a message, it publishes to the broker.
- The broker sends it to Server 2, which pushes to user B.
This is a classic pattern for real-time systems.
Example Architectures for Real-Time Features
Example: Chat Feature
Let us design a simple chat backend at a high level.
Components:
- REST API (for example FastAPI):
POST /roomsto create a room.GET /rooms/{id}/messagesto load the last 50 messages.POST /rooms/{id}/messagesto send a message.- WebSocket server endpoint:
/ws/rooms/{id}for live updates. - Database, for example PostgreSQL, for message storage.
- Redis pub/sub for distribution.
Flow for sending a message:
- Client sends
POST /rooms/5/messageswith JSON{ "text": "Hello" }. - API:
- Checks permissions.
- Saves message to
messagestable withroom_id = 5. - Publishes a message to Redis channel
room.5with message data. - Each WebSocket server is subscribed to
room.5in Redis. - WebSocket server receives the event and sends it to all clients connected to
/ws/rooms/5.
Flow for receiving messages:
- User connects:
ws://.../ws/rooms/5. - Server authenticates and registers connection in room 5.
- When Redis publishes
room.5events, server forwards them to all room 5 connections.
This setup allows many servers to share the same chat rooms.
Example: Live Metrics Dashboard with SSE
Goal:
- Show CPU usage of servers updated every second.
Components:
- Metrics collector that gathers CPU data and stores it in memory or Redis.
- SSE endpoint
/metrics/stream.
Flow:
- Browser uses
new EventSource('/metrics/stream'). - Server sets
Content-Type: text/event-streamand flushes data every second:
event: cpu
data: {"server":"api-1","usage":57}
event: cpu
data: {"server":"api-2","usage":44}- Client JavaScript updates dashboard graphs on each event.
This is one-way streaming from server to client, using a simple HTTP connection.
Handling Failures and Reconnection
Real-time connections are more fragile than simple HTTP requests. Networks drop, Wi-Fi jumps between routers, laptops sleep and wake.
You need strategies for:
- Reconnecting
- Resynchronizing state
- Avoiding message loss or duplication
Reconnection Strategies
Client logic should:
- Try to reconnect automatically if the connection is lost.
- Use increasing delays between attempts to avoid flooding the server.
Example simple strategy:
- 1st retry after 1 second
- 2nd retry after 2 seconds
- 3rd retry after 4 seconds
- Up to a maximum delay, for example 30 seconds
This is called exponential backoff.
Resynchronizing State
When reconnection happens, client may have missed events.
Patterns:
- Use a “last seen message id”:
- Client stores the id of the last message.
- After reconnect, client calls a REST endpoint:
GET /rooms/5/messages?after_id=123.- Server returns all messages after 123.
- Or use version numbers:
- For each resource, keep a
versionnumber. - On reconnect, client asks for the latest version and resets local state.
The key idea is that real-time channels are best-effort, and the source of truth is usually a database behind a REST API.
Choosing the Right Technology
Use this table as a guide:
| Requirement | Technique to consider |
|---|---|
| Rare updates, delay of seconds is fine | Simple polling |
| Frequent updates, still simple setup | Long polling |
| Server-only push (notifications, dashboards) | SSE |
| Two-way communication (chat, games) | WebSockets |
| Many servers, high scale | WebSockets + broker (Redis, Kafka) |
| Streaming text or logs | SSE or WebSockets |
Often you will mix them:
- Use REST for core CRUD.
- Use SSE for broadcasting metrics.
- Use WebSockets for interactive features like chat.
Data Formats and Message Design
In real-time messages you still need:
- Clear structure
- Versioning
- Validation
Common practice:
- Use JSON for WebSocket and SSE messages.
- Include a
typefield and apayloadfield.
Example WebSocket message:
{
"type": "chat.message",
"payload": {
"id": 123,
"room_id": 5,
"text": "Hello",
"author": "alice",
"created_at": "2026-08-28T10:00:00Z"
}
}On the server:
- Parse JSON.
- Use a dispatcher that calls different handlers based on
type.
On the client:
- Switch on
typeto update the correct part of the UI.
Versioning:
- Add a
versionfield for the protocol:
{
"version": 1,
"type": "chat.message",
"payload": { ... }
}When you change the message format later, you can handle old and new versions in parallel.
Security Considerations in Real-Time Apps
Security rules from standard APIs still apply, but there are extra considerations.
Important real-time security rules:
- Always authenticate connections before accepting messages.
- Never trust messages from clients without validation.
- Treat every message like an API request with its own authorization checks.
Key points:
- Use the same authentication tokens used by your HTTP APIs.
- Validate the token at connection time.
- Authorize each action:
- In chat, check that user is in the room before accepting message.
- In live dashboard, check that user has permission to view metrics.
- Limit message rates per connection to avoid abuse.
- Consider maximum message sizes to prevent memory issues.
Putting It All Together
Real-time applications extend your backend beyond simple request-response. They let you:
- Push updates as they happen.
- Keep users in sync with the latest data.
- Build more interactive and collaborative tools.
The core patterns are:
- Choose the right technique (polling, long polling, SSE, WebSockets).
- Combine real-time connections with REST APIs and databases.
- Use message brokers for scale and distribution.
- Handle disconnections, reconnections, and missing messages.
- Use authentication, authorization, and validation on every live connection.
As a backend developer, you do not need to implement everything from scratch. Frameworks, libraries, and managed services can handle much of the low-level work. Your focus is on designing clear protocols, secure flows, and robust data handling so that your real-time features stay correct and reliable as your system grows.
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!