27.2. Server-Sent Events
Table of Contents
Understanding Server-Sent Events
Server-Sent Events (SSE) let a server push data to the browser over a single long‑lived HTTP connection. Unlike WebSockets, SSE is one‑way, from server to client, and is built directly on top of HTTP.
SSE is a good fit when the client only needs to receive updates, such as notifications, live logs, progress updates, or live scores.
Basic Idea of Server-Sent Events
With normal HTTP, the client makes a request, the server responds, and the connection closes. With SSE, the client makes one request and the server keeps that HTTP connection open. Whenever there is new data, the server sends a small text message over the same connection.
In the browser, you use the EventSource API to connect to an SSE endpoint:
const source = new EventSource('/events');
source.onmessage = (event) => {
console.log('New message:', event.data);
};
source.onerror = (err) => {
console.error('SSE error', err);
};On the backend, you expose an endpoint that:
- Uses HTTP GET.
- Returns content type
text/event-stream. - Never fully finishes, or finishes only when the stream ends.
- Sends data in a specific text format.
Key properties of SSE:
- Client connects using HTTP GET to an endpoint.
- Response header must include
Content-Type: text/event-stream. - Messages are sent as UTF‑8 encoded text lines that follow the SSE format.
- The HTTP connection is kept open as long as possible.
- The browser will automatically reconnect if the connection drops, unless disabled.
The SSE Message Format
SSE messages are just lines of text with special prefixes. The most common are:
data:for the message body.event:for a custom event name.id:for a message identifier.retry:to hint a reconnection delay in milliseconds.
An SSE stream is a sequence of messages separated by a blank line.
Minimal message
The simplest message has only a data: line:
data: Hello, world!The blank line at the end means "end of this message".
Multiline data
If the message body spans multiple lines, repeat data::
data: Line 1
data: Line 2
data: Line 3
The browser will join them with \n into one event.data string.
Custom event names
You can name events and listen to them separately:
event: notification
data: You have a new message
event: metrics
data: {"cpu": 0.42, "memory": 0.78}On the client:
const source = new EventSource('/events');
source.addEventListener('notification', (event) => {
console.log('Notification:', event.data);
});
source.addEventListener('metrics', (event) => {
const metrics = JSON.parse(event.data);
console.log('Metrics:', metrics);
});
If you omit event:, the browser treats it as a message event and calls onmessage.
Message IDs and retry
The id: line assigns an ID to a message, which browsers use for automatic reconnection. The retry: line tells the client how long to wait before reconnecting.
Example:
id: 1
retry: 5000
data: First message
id: 2
data: Second messageIf the connection drops, the browser will:
- Reconnect to the same URL.
- Send
Last-Event-ID: 2header (the lastidit saw). - Wait
retrymilliseconds (if set) before reconnecting.
You can use Last-Event-ID on the server to resume from where you stopped.
SSE vs WebSockets vs Polling
SSE is one tool among several for server to client updates.
| Feature | SSE | WebSockets | Long / Short Polling |
|---|---|---|---|
| Direction | Server → Client only | Bidirectional | Client → Server (pull) |
| Protocol | HTTP | Custom over TCP / HTTP upgrade | HTTP |
| Browser API | EventSource | WebSocket | fetch() / XMLHttpRequest |
| Message format | Text (UTF‑8) | Text or binary | Any HTTP response |
| Auto reconnection | Yes, built‑in | Manual | Not needed, new request each time |
| Works with proxies | Usually yes, plain HTTP | Sometimes tricky | Yes |
| Complexity | Low | Higher | Low to medium |
Use SSE when:
- You only need server to client updates.
- You prefer simple text messages (often JSON).
- You want to avoid the complexity of WebSockets.
If you need the client to send frequent real‑time messages to the server, WebSockets are usually a better fit.
HTTP Response Requirements
For an SSE endpoint, the HTTP response must be carefully set up.
Required headers
Basic headers:
HTTP/1.1 200 OK
Content-Type: text/event-stream
Cache-Control: no-cache
Connection: keep-aliveDetails:
Content-Type: text/event-streamtells the browser to treat this as SSE.Cache-Control: no-cacheavoids proxies caching the stream.Connection: keep-alivehelps keep the TCP connection open.
In some setups, you may also add:
X-Accel-Buffering: nofor Nginx to disable buffering.Access-Control-Allow-Origin: ...if using CORS.
Streaming and flushing
The server must:
- Write messages incrementally.
- Flush them so the client receives them immediately.
- Not close the connection until the stream is finished or timed out.
In many frameworks, this means using streaming responses or generator functions.
Example: Simple SSE Endpoint (Python / FastAPI)
FastAPI does not have a special SSE type, but you can use StreamingResponse to send the event stream.
Backend example:
import asyncio
import json
from fastapi import FastAPI
from starlette.responses import StreamingResponse
app = FastAPI()
async def event_generator():
counter = 0
while True:
await asyncio.sleep(1)
counter += 1
data = {"counter": counter}
# Build SSE message
message = f"data: {json.dumps(data)}\n\n"
yield message
@app.get("/events")
async def events():
return StreamingResponse(
event_generator(),
media_type="text/event-stream",
)Client example:
<!doctype html>
<html>
<body>
<div id="output"></div>
<script>
const output = document.getElementById('output');
const source = new EventSource('/events');
source.onmessage = (event) => {
const data = JSON.parse(event.data);
output.textContent = 'Counter: ' + data.counter;
};
source.onerror = (err) => {
console.error('SSE error', err);
};
</script>
</body>
</html>Every second, the client receives a new message and updates the page.
Custom Event Types Example
You can use event: to define different types of updates. For instance, suppose you have three kinds of events:
statusfor status changes.logfor log messages.progressfor progress updates.
Backend (simplified):
async def event_generator():
# status event
yield "event: status\ndata: started\n\n"
await asyncio.sleep(1)
# log event
yield "event: log\ndata: Step 1 completed\n\n"
await asyncio.sleep(1)
# progress event
yield "event: progress\ndata: 50\n\n"
await asyncio.sleep(1)
# final status
yield "event: status\ndata: finished\n\n"Client:
const source = new EventSource('/job-events');
source.addEventListener('status', (event) => {
console.log('Status:', event.data);
});
source.addEventListener('log', (event) => {
console.log('Log:', event.data);
});
source.addEventListener('progress', (event) => {
console.log('Progress:', event.data + '%');
});Handling Reconnection and Last-Event-ID
Browsers automatically reconnect on errors. You can use message IDs to continue from the last event.
Backend:
from fastapi import Request
async def event_generator(last_id: int):
current = last_id
while True:
await asyncio.sleep(1)
current += 1
data = {"counter": current}
message = f"id: {current}\ndata: {json.dumps(data)}\n\n"
yield message
@app.get("/events")
async def events(request: Request):
# Read Last-Event-ID, default to 0 if missing
last_id_header = request.headers.get("Last-Event-ID")
last_id = int(last_id_header) if last_id_header is not None else 0
generator = event_generator(last_id)
return StreamingResponse(generator, media_type="text/event-stream")
If the connection drops after message with id: 5, on reconnection the browser will send:
Last-Event-ID: 5Your server can use this to resume from ID 6.
Important SSE reconnection rules:
- Each message can have an
id:line. - The browser remembers the last
idit saw. - On reconnect, the browser sends
Last-Event-IDheader. - You can use
Last-Event-IDto avoid resending old events.
Common Use Cases
SSE is especially useful for:
Live notifications
For example, notifying a user when:
- A background task finishes.
- They receive a new message.
- A watched resource changes.
The client opens an EventSource when the web app loads and listens for notification events.
Live dashboards
For metrics and logs that need continuous updates:
- Server performance charts.
- Real‑time analytics.
- Application logs.
The server broadcasts new metrics to all connected SSE clients.
Progress updates for long tasks
Instead of polling a /status endpoint, the browser can:
- Kick off a long‑running job via a normal POST.
- Open an SSE connection to
/jobs/{id}/events. - Receive
progressandstatusevents until the job completes.
This is often simpler than maintaining WebSocket connections.
Practical Considerations and Limitations
Even though SSE is simple, you need to be aware of some details.
Connection limits
Browsers limit how many concurrent connections can be open to the same domain. This includes SSE connections. Often the limit is around 6 connections.
Avoid opening too many SSE streams per page. Usually, you want only one EventSource and then multiplex different event types over it.
Timeouts and proxies
Some proxies or load balancers close idle connections. Because SSE keeps connections open and can be relatively idle, you may need:
- Periodic heartbeat messages:
: heartbeat
Lines beginning with : are comments and are ignored by the browser, but keep the connection active.
- Proper configuration of idle timeouts on your reverse proxy (like Nginx or Traefik).
No binary data
SSE is text only. If you need to send binary data, you must encode it, for example with Base64, or use WebSockets instead. In practice, most SSE messages are JSON text, which works well.
CORS and authentication
SSE uses HTTP, so all normal HTTP concerns apply:
- CORS headers for cross‑origin access.
- Cookies, headers, or tokens for authentication.
- Security headers from your backend security configuration.
Many applications secure SSE endpoints with the same mechanisms as their normal APIs.
Example: Incremental Logs via SSE
Imagine you have a background process that produces logs as it runs. You can stream those logs to the client in real time.
Backend example structure:
import asyncio
from fastapi import FastAPI
from starlette.responses import StreamingResponse
app = FastAPI()
async def log_stream():
logs = [
"Starting job",
"Downloading data",
"Processing data",
"Saving results",
"Job complete"
]
for line in logs:
await asyncio.sleep(1)
yield f"event: log\ndata: {line}\n\n"
@app.get("/job/logs")
async def job_logs():
return StreamingResponse(log_stream(), media_type="text/event-stream")Client:
const source = new EventSource('/job/logs');
source.addEventListener('log', (event) => {
const el = document.createElement('div');
el.textContent = event.data;
document.body.appendChild(el);
});The user sees the logs appear line by line while the job is running.
When Not to Use SSE
SSE is not always the right choice. Avoid SSE when:
- You need full bidirectional real‑time communication between client and server. WebSockets are better for chat apps or collaborative editing.
- You need to send large amounts of binary data. Use WebSockets or plain HTTP downloads.
- Your environment has strict limitations on long‑lived HTTP connections and you cannot change proxy or server settings.
In many backend systems, a combination of technologies is common. For example:
- Use REST for normal CRUD.
- Use SSE for one‑way updates.
- Use WebSockets only where true bidirectional streaming is required.
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!