6.1. Building a Simple Web Server
Table of Contents
Understanding What You Are Building
Before you write any code, it helps to understand what a "simple web server" actually does.
At the most basic level, a web server:
- Listens on a network port (often port 8000 or 8080 during development).
- Waits for HTTP requests from clients, such as browsers or tools like
curl. - Reads the request, then decides how to respond.
- Sends back an HTTP response: a status line, headers, and an optional body (like HTML or JSON).
You already covered how HTTP and requests / responses work in earlier chapters, so here we will focus on building such a server, step by step, using Python.
Using Python’s Built-in HTTP Server
Python includes modules that let you create a very simple web server with almost no code. These are useful for quick tests and for understanding what a server does behind the scenes.
The Simplest Possible Server
If you only want to serve files from a folder over HTTP, Python gives you a one-liner.
From a terminal, run:
python -m http.server 8000This does the following:
- Starts a server on port
8000. - Uses the current directory as the web root.
- Serves files using the
GETmethod.
Now open a browser and visit:
http://localhost:8000You will see:
- A directory listing of your current folder, or
- If there is an
index.htmlfile, that file will be served.
You can stop the server with Ctrl + C in the terminal.
This built-in server is useful to quickly test HTML, CSS, or JavaScript, but it is very limited:
- You cannot easily change how requests are handled.
- You do not control the logic of responses.
To really understand web backends, you need to handle requests yourself.
Building a Minimal HTTP Server in Python
Python’s http.server module lets you write your own request handler. This gives you control over what gets returned.
A Basic “Hello, World” Web Server
Create a file called basic_server.py:
from http.server import HTTPServer, BaseHTTPRequestHandler
class SimpleHandler(BaseHTTPRequestHandler):
def do_GET(self):
# Set status code
self.send_response(200)
# Set headers
self.send_header("Content-Type", "text/plain; charset=utf-8")
self.end_headers()
# Set response body
message = "Hello, world! This is my first web server."
self.wfile.write(message.encode("utf-8"))
def run_server():
host = "localhost"
port = 8000
server_address = (host, port)
httpd = HTTPServer(server_address, SimpleHandler)
print(f"Serving on http://{host}:{port}")
httpd.serve_forever()
if __name__ == "__main__":
run_server()Run it:
python basic_server.pyVisit:
http://localhost:8000You should see the plain text response.
Breaking Down the Code
HTTPServer:- Manages the socket.
- Listens for incoming connections.
- Passes each request to your handler.
BaseHTTPRequestHandler:- Represents a single HTTP request.
- Provides methods like
do_GET,do_POST, etc. - You override these to control behavior.
do_GET(self):- Called automatically for every incoming GET request.
Inside do_GET:
self.send_response(200)
Sets the HTTP status code to 200 OK.self.send_header("Content-Type", "text/plain; charset=utf-8")
Adds a header. You must callself.end_headers()after sending all headers.self.wfile.write(...)
Writes the body of the response as bytes.
Always send headers before writing the response body, and always write bytes, not strings.
If you forget self.end_headers(), most clients will not understand the response correctly.
Handling Different Paths (Routes)
Most real servers respond differently based on the URL path, for example /, /about, /api/users.
In a very simple server without a framework, you inspect self.path and branch manually.
Example: Multiple Paths in `do_GET`
from http.server import HTTPServer, BaseHTTPRequestHandler
import json
class SimpleRouterHandler(BaseHTTPRequestHandler):
def _send_json(self, data, status=200):
response_bytes = json.dumps(data).encode("utf-8")
self.send_response(status)
self.send_header("Content-Type", "application/json; charset=utf-8")
self.send_header("Content-Length", str(len(response_bytes)))
self.end_headers()
self.wfile.write(response_bytes)
def _send_text(self, text, status=200):
response_bytes = text.encode("utf-8")
self.send_response(status)
self.send_header("Content-Type", "text/plain; charset=utf-8")
self.send_header("Content-Length", str(len(response_bytes)))
self.end_headers()
self.wfile.write(response_bytes)
def do_GET(self):
if self.path == "/":
self._send_text("Welcome to the home page")
elif self.path == "/hello":
self._send_text("Hello from /hello")
elif self.path == "/api/info":
data = {"version": "1.0.0", "status": "ok"}
self._send_json(data)
else:
self._send_text("Not found", status=404)
def run_server():
server = HTTPServer(("localhost", 8001), SimpleRouterHandler)
print("Serving on http://localhost:8001")
server.serve_forever()
if __name__ == "__main__":
run_server()Try visiting:
http://localhost:8001/http://localhost:8001/hellohttp://localhost:8001/api/infohttp://localhost:8001/unknown
You will see different responses for each path.
Here we manually implemented a tiny routing system: a chain of if statements based on self.path.
In a real backend framework, you will not write these if statements yourself. Instead, the framework will give you decorators or functions to map URLs to functions. But this manual approach helps you see what is happening underneath.
Handling Different HTTP Methods
A web server does not only handle GET. You will often need POST for creating data, PUT or PATCH for updating, and DELETE for removing.
BaseHTTPRequestHandler lets you define methods such as:
do_GETdo_POSTdo_PUTdo_PATCHdo_DELETE
Each one is called when a request with the corresponding HTTP method arrives.
Example: Support GET and POST
Create method_server.py:
from http.server import HTTPServer, BaseHTTPRequestHandler
import json
class MethodHandler(BaseHTTPRequestHandler):
def _parse_json_body(self):
# Read Content-Length header
content_length_header = self.headers.get("Content-Length")
if not content_length_header:
return None
try:
length = int(content_length_header)
except ValueError:
return None
# Read raw bytes
raw_body = self.rfile.read(length)
try:
return json.loads(raw_body.decode("utf-8"))
except json.JSONDecodeError:
return None
def _send_json(self, data, status=200):
response_bytes = json.dumps(data).encode("utf-8")
self.send_response(status)
self.send_header("Content-Type", "application/json; charset=utf-8")
self.send_header("Content-Length", str(len(response_bytes)))
self.end_headers()
self.wfile.write(response_bytes)
def do_GET(self):
if self.path == "/items":
items = [
{"id": 1, "name": "Apple"},
{"id": 2, "name": "Banana"},
]
self._send_json(items)
else:
self._send_json({"error": "Not found"}, status=404)
def do_POST(self):
if self.path == "/items":
data = self._parse_json_body()
if data is None:
self._send_json({"error": "Invalid JSON"}, status=400)
return
# In a real app you would save to a database.
# Here we just echo back what we received.
created_item = {
"id": 123,
"name": data.get("name"),
}
self._send_json(created_item, status=201)
else:
self._send_json({"error": "Not found"}, status=404)
def run_server():
server = HTTPServer(("localhost", 8002), MethodHandler)
print("Serving on http://localhost:8002")
server.serve_forever()
if __name__ == "__main__":
run_server()Run:
python method_server.pyIn another terminal, send a GET request:
curl http://localhost:8002/itemsYou should get a JSON list.
Now send a POST with JSON:
curl -X POST http://localhost:8002/items \
-H "Content-Type: application/json" \
-d '{"name": "Orange"}'You will get back a JSON object representing the created item.
When handling POST or PUT requests with a body:
- Always read exactly the number of bytes specified in the
Content-Lengthheader. - Always decode bytes using the correct charset, commonly UTF-8.
- Always validate or at least check the parsed data before using it.
Simple Error Handling and Status Codes
Even a basic web server should use meaningful HTTP status codes.
Common ones you will use here:
| Code | Meaning | Typical Use |
|---|---|---|
| 200 | OK | Successful GET, PUT, PATCH, DELETE |
| 201 | Created | New resource created, often for POST |
| 400 | Bad Request | Invalid input, malformed JSON |
| 404 | Not Found | Path or resource does not exist |
| 405 | Method Not Allowed | HTTP method not supported for this endpoint |
| 500 | Internal Server Error | Unhandled exception on the server |
Returning 404 for Unknown Paths
You already saw an example:
self._send_text("Not found", status=404)Returning 400 for Bad Data
In the POST example:
if data is None:
self._send_json({"error": "Invalid JSON"}, status=400)
returnUse status codes consistently. Do not return 200 OK for requests that clearly failed.
Frameworks will automate much of this for you, but understanding how to choose codes is important.
Logging Requests for Debugging
When building servers, it helps to see incoming requests.
BaseHTTPRequestHandler already logs some information, but you can customize it.
from http.server import HTTPServer, BaseHTTPRequestHandler
import time
class LoggingHandler(BaseHTTPRequestHandler):
def log_message(self, format, *args):
# Override default logging format
timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
message = "%s - %s" % (self.address_string(), format % args)
print(f"[{timestamp}] {message}")
def do_GET(self):
print(f"Handling GET {self.path}")
self.send_response(200)
self.end_headers()
self.wfile.write(b"Check the server logs for request info.")Now every request will appear with a custom log line in your terminal.
Logging will become a bigger topic later, but even in simple servers it is useful to know where to add print or logging calls to see what is happening.
Serving Simple HTML
So far we returned plain text or JSON. Backend servers often return HTML, especially in projects that use server-side templates.
You can send HTML the same way you send text. You only change the Content-Type.
from http.server import HTTPServer, BaseHTTPRequestHandler
class HTMLHandler(BaseHTTPRequestHandler):
def do_GET(self):
if self.path == "/":
html = """
<!DOCTYPE html>
<html>
<head>
<title>My Simple Server</title>
</head>
<body>
<h1>Hello from a simple HTML page</h1>
<p>This HTML comes from a Python server.</p>
</body>
</html>
"""
html_bytes = html.encode("utf-8")
self.send_response(200)
self.send_header("Content-Type", "text/html; charset=utf-8")
self.send_header("Content-Length", str(len(html_bytes)))
self.end_headers()
self.wfile.write(html_bytes)
else:
self.send_response(404)
self.end_headers()
self.wfile.write(b"Not found")
def run_server():
server = HTTPServer(("localhost", 8003), HTMLHandler)
print("Serving on http://localhost:8003")
server.serve_forever()
if __name__ == "__main__":
run_server()
Visit http://localhost:8003/ and you will see an HTML page rendered in the browser.
In later chapters you will learn about templates that let you keep HTML in separate files and insert dynamic content. For now this example shows the basic idea.
Why Frameworks Exist
The servers you are building here are extremely simple and lack many things you actually want:
- Easy URL routing without
if self.path == .... - Automatic parsing of query parameters and request bodies.
- Simple JSON handling.
- Built-in validation of input.
- Automatic 404, 405, and error responses.
- Middleware support (for logging, authentication, etc).
- Integration with templates, databases, and more.
It is possible to build all of this with the standard library, but it is a lot of code and easy to get wrong.
Frameworks like FastAPI, Flask, or Django sit on top of lower level servers and give you:
- A nicer API for defining routes.
- Helper functions for returning responses.
- Tools for common backend tasks.
This chapter focused on a "from scratch" approach so you know what is going on under the hood. In the rest of this section you will build on these ideas using actual web frameworks that remove much of the boilerplate and give you a more productive way to build real applications.
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!