27.1. WebSockets
Table of Contents
Why WebSockets Exist
HTTP is request-response and usually one-way. The client sends a request, the server replies, and the connection is done or kept alive only for more requests. If you want live updates, you often end up polling:
- Client: “Any new messages?” every 3 seconds
- Server: “Nope” or “Here is something”
This wastes resources and does not feel instant.
WebSockets solve this by creating a persistent, full-duplex connection between client and server. After the initial HTTP handshake, both sides can send messages to each other at any time until the connection is closed.
Typical use cases:
- Chat applications
- Live dashboards and stock tickers
- Multiplayer games
- Collaborative editing (Google Docs style)
- Real-time notifications
In all of these, you need low-latency, bidirectional communication and do not want to re-open a connection on every update.
Key idea: WebSockets keep one long-lived connection open, and both client and server can send messages at any time, without waiting for a request.
The WebSocket Handshake
WebSockets begin as a normal HTTP/1.1 request. The client says, “I would like to upgrade this HTTP connection to WebSocket.” If the server agrees, it responds and both sides switch to the WebSocket protocol on the same TCP connection.
A typical WebSocket handshake request from a browser looks like:
GET /chat HTTP/1.1
Host: example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==
Sec-WebSocket-Version: 13
Origin: https://example.comImportant headers:
Upgrade: websocket
Asks to switch protocols from HTTP to WebSocket.Connection: Upgrade
Says theUpgradeheader should be processed.Sec-WebSocket-Key
A random base64 string that the server uses to prove it accepts the protocol.
The server replies:
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: HSmrc0sMlYUkAGmm5OPpG2HaGWk=
Status 101 means “Switching Protocols.” After this, the data on the connection is no longer HTTP. It is WebSocket frames.
Table summary:
| Step | Who | What happens |
|---|---|---|
| HTTP upgrade request | Client | Sends Upgrade: websocket headers |
| Upgrade decision | Server | Validates headers, decides to accept |
| HTTP 101 response | Server | Sends Sec-WebSocket-Accept and status |
| Protocol switch | Both | Start sending WebSocket frames |
You usually do not implement this handshake by hand. Libraries and frameworks handle it. But it is important to know that WebSockets are not a separate port or magic protocol. They are:
- HTTP/1.1 connection
- Upgrade to WebSocket
WebSocket Connections and Messages
Once the handshake is done, the WebSocket connection is:
- Persistent
It stays open until one side closes it or a network error occurs. - Full-duplex
Client and server can talk at the same time. - Framed
Data is sent as frames, which contain type and payload.
Message Types
Most libraries abstract frames away and give you messages. Common message types:
- Text messages
Typically UTF-8 strings such as JSON. - Binary messages
Raw binary data, for example images or protocol buffers. - Control frames
Used for pings, pongs, and closing the connection.
In a typical backend, you will mostly send and receive text messages encoded as JSON.
Example JSON chat message:
{
"type": "message",
"room": "general",
"sender": "alice",
"text": "Hello, everyone!",
"timestamp": "2026-08-28T12:34:56Z"
}It is common to define a message format like this so client and server both know how to interpret messages.
Important rule: Always define a clear JSON schema for your WebSocket messages, including a type field, so you can safely parse and route different message kinds.
WebSocket vs HTTP APIs
You already know how to build REST or HTTP APIs. WebSockets are different in several important ways.
Communication Pattern
| Feature | HTTP / REST | WebSocket |
|---|---|---|
| Direction | Client → Server (request), Server → Client (response only) | Both directions at any time |
| Connection life | Short-lived (per request), or reused with keep-alive | Long-lived until closed |
| Typical use | CRUD, resources, business operations | Real-time updates, events, streams |
With HTTP:
- Client calls
POST /messages - Client polls
GET /messagesfor updates
With WebSockets:
- Client sends
"new_message"via WebSocket - Server immediately sends
"message_created"events to other connected clients
State and Protocol Design
HTTP APIs are usually stateless per request. Every request carries all necessary information.
WebSockets often have a stateful session on the server side:
- Which user is connected
- Which rooms / topics they are subscribed to
- What permissions they have
This means:
- You must explicitly handle authentication and authorization when the connection is created.
- You must carefully manage memory and cleanup when connections close.
When to Use WebSockets Instead of HTTP
Use WebSockets when:
- You need fast, real-time updates from server to client
- You need continuous streams of data
- You need interactive, bidirectional communication
Use only HTTP APIs when:
- You mostly do classic CRUD operations
- Slight delays are acceptable
- You do not want the complexity of managing long-lived connections
It is common to combine both: REST for normal operations and WebSockets for live updates.
Basic WebSocket Flow with an Example
Consider a simple chat room feature.
Step 1: Client Connects
Client uses JavaScript in the browser:
const socket = new WebSocket("wss://api.example.com/ws/chat");
socket.onopen = () => {
console.log("Connected to chat");
};
socket.onmessage = (event) => {
const data = JSON.parse(event.data);
console.log("New message:", data);
};
socket.onclose = () => {
console.log("Disconnected from chat");
};
Note the wss:// scheme:
ws://is WebSocket over plain TCPwss://is WebSocket over TLS, similar to HTTPS vs HTTP
Step 2: Client Sends a Message
socket.send(JSON.stringify({
type: "message",
room: "general",
text: "Hello from the browser!"
}));On the backend (pseudo Python code):
async def chat_websocket(websocket):
await websocket.accept()
try:
while True:
raw = await websocket.receive_text()
data = json.loads(raw)
if data["type"] == "message":
print("Message received:", data["text"])
# Here you might broadcast to others
except WebSocketDisconnect:
print("Client disconnected")Important things you can see:
- The server accepts the connection once the handshake is done.
- After that, there is a loop that receives messages until the client disconnects or an error occurs.
- Messages are JSON strings, so server and client must agree on the format.
Step 3: Server Sends Messages
The server can send messages at any time:
await websocket.send_text(json.dumps({
"type": "system",
"text": "Welcome to the chat!"
}))
The client will receive this in its onmessage handler.
Handling Disconnections and Errors
WebSockets are long-lived, but they are not permanent. Clients close browser tabs, networks drop, servers restart.
You need to:
- Detect disconnects
- Clean up server-side state
- Optionally attempt reconnection on the client
Common close reasons:
- Client calls
socket.close() - Server decides to close the connection
- Network errors or timeouts
Example of a client with simple reconnection logic:
function connect() {
const socket = new WebSocket("wss://api.example.com/ws/chat");
socket.onopen = () => {
console.log("Connected");
};
socket.onclose = (event) => {
console.log("Disconnected, trying to reconnect in 3s...");
setTimeout(connect, 3000);
};
socket.onerror = (error) => {
console.error("WebSocket error:", error);
socket.close();
};
}
connect();
On the server, you often wrap your receive loop in a try / except and remove the client from any subscription lists when a WebSocketDisconnect or equivalent is raised.
Always clean up server-side state when a WebSocket closes, or you risk memory leaks and stale subscriptions.
Broadcasting and Multiple Clients
In many real-time applications, you have many clients listening to the same events.
For example, in a chat room:
- User A sends a message
- Server receives it
- Server sends the new message to all clients in that room
A very simplified server-side structure might be:
rooms = {
"general": set(), # each item is a websocket connection
"random": set(),
}
async def chat_websocket(websocket, room_name):
await websocket.accept()
rooms[room_name].add(websocket)
try:
while True:
raw = await websocket.receive_text()
data = json.loads(raw)
if data["type"] == "message":
# Broadcast to all clients in the room
for client in rooms[room_name]:
await client.send_text(raw)
except WebSocketDisconnect:
rooms[room_name].remove(websocket)This example:
- Keeps track of connections per room using sets
- Sends each incoming message to every client in that room
- Removes connections on disconnect
In production systems you usually:
- Store connection lists in a more scalable structure
- Use a message broker like Redis pub/sub to broadcast across multiple server instances
- Limit which messages can be broadcast from which users (authorization)
Message Design and Versioning
Because WebSockets often carry free-form JSON, it is very easy to create a mess where no one knows what messages mean.
Good practices for message design:
- Always include a
typefield
Example types:"message","typing","join","leave","ping". - Define a contract
Document what each type expects and returns. - Allow for versioning
You might include aversionfield or design messages so old clients can ignore unknown fields safely.
Example, slightly more robust JSON message:
{
"type": "message",
"version": 1,
"payload": {
"room": "general",
"text": "Hello",
"sender": "alice"
}
}On the server:
data = json.loads(raw)
msg_type = data.get("type")
version = data.get("version", 1)
payload = data.get("payload", {})
if msg_type == "message" and version == 1:
text = payload["text"]
# handle messageTreat WebSocket messages like API contracts. Validate them and handle unknown or invalid messages gracefully, instead of assuming they are correct.
Scaling Considerations
Even though this course has separate chapters for performance and scalability, a few WebSocket-specific ideas are useful here.
Many Connections
Each WebSocket connection usually maps to:
- A TCP connection
- Some memory on the server
- Possibly a task or thread waiting for data
To support many connections:
- Use an asynchronous server that can handle multiple sockets concurrently
- Tune OS limits, like max open file descriptors
- Consider horizontal scaling with multiple server instances
Multiple Server Instances
If you run multiple backend instances behind a load balancer, a message received on instance A might need to be delivered to a client connected to instance B.
To handle this:
- Use a shared message bus, such as Redis pub/sub
- When a message arrives, publish it to a channel
- All instances subscribed to that channel broadcast to their local connections
Example conceptual flow:
- Client 1 (connected to server A) sends chat message.
- Server A publishes the message to
chat.generalin Redis. - Servers A, B, C are subscribed to
chat.general. Each receives the message. - Each server sends the message only to its local clients in that room.
You do not need to implement this now, but it is important to see that WebSockets interact strongly with architecture and scaling decisions.
Security Basics for WebSockets
Full backend security is covered elsewhere, but a few focused points for WebSockets:
- Authenticate the connection
Use a token or session when the WebSocket is created. You can pass a token in: - A query parameter (for example
wss://example.com/ws/chat?token=...) - A header, if your client supports custom headers
- The first message after the connection opens
- Authorize actions
Check permissions before letting a user: - Join a room
- Subscribe to certain event types
- Perform administrative operations
- Validate input
Treat incoming WebSocket messages like HTTP requests: - Parse JSON
- Validate fields and types
- Enforce limits on sizes and rates
- Use WSS in production
Always usewss://so data is encrypted on the wire.
Never trust data coming from a WebSocket client. Always authenticate, authorize, and validate, just like for normal HTTP APIs.
Summary
WebSockets give your backend the ability to:
- Keep long-lived connections
- Send and receive messages at any time
- Build real-time features without constant polling
You learned:
- How the WebSocket handshake upgrades from HTTP to a persistent connection
- How messages flow in both directions
- How WebSockets differ from normal HTTP APIs
- How to handle disconnects, broadcasting, and message design
- Basic scalability and security considerations for WebSockets
In the larger picture of backend development, WebSockets are a specialized tool. You will still use HTTP and REST for most operations, but WebSockets become essential when your application needs real-time, interactive communication.
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!