6.8. Returning Responses
Table of Contents
Understanding Responses in Web Backends
When a client sends a request, your backend must send something back. That "something" is the response. In this chapter you will see what a response is, what it can contain, and how to build useful responses in a simple Python web backend.
You will not learn a specific framework in depth here, that comes later with FastAPI, but the ideas are the same for any backend.
What Is an HTTP Response?
An HTTP response is the message that the server sends back to the client after handling a request. Every response has three main parts:
- Status line
Example:
HTTP/1.1 200 OK
It includes: - HTTP version
- Status code, for example
200 - Reason phrase, for example
OK - Headers
Key value pairs that describe the response, for example: Content-Type: text/htmlContent-Length: 123Set-Cookie: session=abc123; HttpOnly- Body (optional)
The actual content, such as: - HTML for a web page
- JSON for an API
- Image bytes
- File contents
Example of a raw HTTP response:
HTTP/1.1 200 OK
Content-Type: text/plain; charset=utf-8
Content-Length: 12
Hello world!The blank line between headers and body is required. After that blank line, everything is the body.
A valid HTTP response must include:
- A status line with a status code, for example
HTTP/1.1 200 OK - Zero or more headers
- A blank line
- Optional body data
If you omit the status line, the response is invalid.
Returning Different Content Types
The Content-Type header tells the client how to interpret the body. Returning the right content type is critical for correct behavior.
Common content types:
| Content type | Description | Typical use |
|---|---|---|
text/plain | Plain text | Simple messages, debugging |
text/html | HTML content | Web pages |
application/json | JSON data | APIs, single page applications |
image/png | PNG image | Serving images |
application/octet-stream | Arbitrary binary data | File downloads |
Example: Plain Text Response (Python WSGI style)
def app(environ, start_response):
body = b"Hello from backend"
status = "200 OK"
headers = [
("Content-Type", "text/plain; charset=utf-8"),
("Content-Length", str(len(body))),
]
start_response(status, headers)
return [body]Example: HTML Response
def app(environ, start_response):
html = b"""
<html>
<head><title>Home</title></head>
<body>
<h1>Welcome</h1>
<p>This is a simple HTML page.</p>
</body>
</html>
"""
status = "200 OK"
headers = [
("Content-Type", "text/html; charset=utf-8"),
("Content-Length", str(len(html))),
]
start_response(status, headers)
return [html]Example: JSON Response
import json
def app(environ, start_response):
data = {"message": "Hello", "status": "ok"}
body_str = json.dumps(data)
body = body_str.encode("utf-8")
status = "200 OK"
headers = [
("Content-Type", "application/json; charset=utf-8"),
("Content-Length", str(len(body))),
]
start_response(status, headers)
return [body]
Notice how only the Content-Type and body format change. The structure of the response is the same.
Always set the correct Content-Type header for the body you send.
For JSON APIs, use Content-Type: application/json.
Controlling Status Codes
Status codes tell the client if the request was successful or not, and what happened.
Some common status codes you will use when returning responses:
| Code | Meaning | Typical use example |
|---|---|---|
| 200 | OK | Successful GET or POST |
| 201 | Created | Resource successfully created |
| 204 | No Content | Successful request with no body |
| 301 | Moved Permanently | Permanent redirect |
| 302 | Found | Temporary redirect |
| 400 | Bad Request | Invalid input |
| 401 | Unauthorized | Authentication required |
| 403 | Forbidden | Not allowed even if authenticated |
| 404 | Not Found | Resource not found |
| 500 | Internal Server Error | Unexpected server error |
Example: Returning Success vs Error
import json
from urllib.parse import parse_qs
def app(environ, start_response):
query = parse_qs(environ.get("QUERY_STRING", ""))
name = query.get("name", [None])[0]
if not name:
# Missing "name" parameter
error = {"error": "name query parameter is required"}
body = json.dumps(error).encode("utf-8")
status = "400 Bad Request"
else:
# All good
data = {"message": f"Hello, {name}!"}
body = json.dumps(data).encode("utf-8")
status = "200 OK"
headers = [
("Content-Type", "application/json; charset=utf-8"),
("Content-Length", str(len(body))),
]
start_response(status, headers)
return [body]From the client side:
- Request:
/hello?name=Alex
Response:200 OKwith JSON body{ "message": "Hello, Alex!" } - Request:
/hello
Response:400 Bad Requestwith JSON body{ "error": "name query parameter is required" }
Do not always return 200 OK.
Choose a status code that matches the outcome of the request, for example:
- 2xx, success
- 4xx, client error such as bad input
- 5xx, server error
Setting Response Headers
Headers give additional information about the response. Some typical response headers you will see and use:
| Header | Example value | Purpose |
|---|---|---|
Content-Type | application/json; charset=utf-8 | Tells client how to read the body |
Content-Length | 123 | Body size in bytes |
Location | /login or full URL | Used in redirects |
Set-Cookie | session=abc123; HttpOnly; Path=/ | Creates or updates cookies |
Cache-Control | no-store or max-age=3600 | Controls caching |
Content-Disposition | attachment; filename="report.pdf" | Controls file download behavior |
Access-Control-Allow-Origin | * or https://example.com | Related to CORS |
Example: Adding Custom Headers
def app(environ, start_response):
body = b"Hello with a custom header"
status = "200 OK"
headers = [
("Content-Type", "text/plain; charset=utf-8"),
("Content-Length", str(len(body))),
("X-App-Version", "1.0.0"), # custom header
]
start_response(status, headers)
return [body]
You can add any header name that starts with X- for custom headers, for example X-Request-Id. In modern APIs, many custom headers are used without X- as well, such as Request-Id. The key point is that both client and server must agree on the meaning.
JSON Responses for APIs
Modern backends often return JSON. JSON is easy to read by both humans and machines. When returning JSON:
- Convert Python data structures to JSON text.
- Encode JSON text as bytes.
- Set
Content-Typetoapplication/json.
Example: Returning a List of Items
import json
def app(environ, start_response):
items = [
{"id": 1, "name": "Apple", "price": 0.5},
{"id": 2, "name": "Banana", "price": 0.3},
{"id": 3, "name": "Orange", "price": 0.8},
]
body = json.dumps(items).encode("utf-8")
status = "200 OK"
headers = [
("Content-Type", "application/json; charset=utf-8"),
("Content-Length", str(len(body))),
]
start_response(status, headers)
return [body]Client sees JSON like:
[
{"id": 1, "name": "Apple", "price": 0.5},
{"id": 2, "name": "Banana", "price": 0.3},
{"id": 3, "name": "Orange", "price": 0.8}
]When building APIs, adopt this rule:
- Rule: Return JSON objects or arrays, not plain text, for structured data.
- Header: Always set
Content-Type: application/jsonwhen sending JSON.
HTML Responses for Web Pages
If your backend serves web pages, you will return HTML. Later chapters will show you how to use templates. For now, a simple HTML response is just a string with HTML content.
Example: Simple HTML Page
def app(environ, start_response):
html = """
<!doctype html>
<html>
<head>
<title>My Page</title>
</head>
<body>
<h1>My First Web Page</h1>
<p>This page is rendered by Python.</p>
</body>
</html>
"""
body = html.encode("utf-8")
status = "200 OK"
headers = [
("Content-Type", "text/html; charset=utf-8"),
("Content-Length", str(len(body))),
]
start_response(status, headers)
return [body]
Modern development usually uses a template engine to generate such HTML dynamically from data. That comes in later chapters. For this chapter you only need to see that HTML is simply text with Content-Type: text/html.
Redirect Responses
Sometimes you do not want to return content directly, but instead tell the client to go somewhere else. This is a redirect.
To redirect:
- Set a 3xx status code, usually
302 Foundor301 Moved Permanently. - Set a
Locationheader to the new URL. - Body is often empty or a short message.
Example: Redirect `"/"` to `"/home"`
def app(environ, start_response):
path = environ.get("PATH_INFO", "/")
if path == "/":
# Redirect to /home
status = "302 Found"
headers = [
("Location", "/home"),
("Content-Length", "0"),
]
start_response(status, headers)
return [b""]
elif path == "/home":
body = b"Welcome to the home page"
status = "200 OK"
headers = [
("Content-Type", "text/plain; charset=utf-8"),
("Content-Length", str(len(body))),
]
start_response(status, headers)
return [body]
else:
body = b"Not found"
status = "404 Not Found"
headers = [
("Content-Type", "text/plain; charset=utf-8"),
("Content-Length", str(len(body))),
]
start_response(status, headers)
return [body]
The browser will automatically follow the redirect and request /home.
Sending Empty Responses
Sometimes you do not need to send a body. For example:
- A successful DELETE operation can return
204 No Content. - A redirect often does not need a body.
In that case:
- Use an appropriate status code.
- Set
Content-Length: 0. - Return an empty body.
Example: `204 No Content`
def app(environ, start_response):
path = environ.get("PATH_INFO", "/")
if path == "/delete-all":
# Imagine that we deleted items here
status = "204 No Content"
headers = [("Content-Length", "0")]
start_response(status, headers)
return [b""]
body = b"Use /delete-all to delete items"
status = "200 OK"
headers = [
("Content-Type", "text/plain; charset=utf-8"),
("Content-Length", str(len(body))),
]
start_response(status, headers)
return [body]File and Binary Responses
Backends also return files, for example:
- Image files, for example user avatars
- PDF reports
- CSV exports
A file response has:
Content-Typethat matches the file type.Content-Lengthequal to the file size in bytes.- Optionally
Content-Dispositionheader to suggest download.
Example: Returning an Image File
import os
def app(environ, start_response):
path = environ.get("PATH_INFO", "/")
if path == "/logo":
file_path = "static/logo.png"
if not os.path.exists(file_path):
body = b"Logo not found"
status = "404 Not Found"
headers = [
("Content-Type", "text/plain; charset=utf-8"),
("Content-Length", str(len(body))),
]
start_response(status, headers)
return [body]
with open(file_path, "rb") as f:
body = f.read()
status = "200 OK"
headers = [
("Content-Type", "image/png"),
("Content-Length", str(len(body))),
]
start_response(status, headers)
return [body]
body = b"Try /logo"
status = "200 OK"
headers = [
("Content-Type", "text/plain; charset=utf-8"),
("Content-Length", str(len(body))),
]
start_response(status, headers)
return [body]Example: Forcing Download (Attachment)
import os
def app(environ, start_response):
path = environ.get("PATH_INFO", "/")
if path == "/download-report":
file_path = "data/report.pdf"
if not os.path.exists(file_path):
body = b"Report not found"
status = "404 Not Found"
headers = [
("Content-Type", "text/plain; charset=utf-8"),
("Content-Length", str(len(body))),
]
start_response(status, headers)
return [body]
with open(file_path, "rb") as f:
body = f.read()
status = "200 OK"
headers = [
("Content-Type", "application/pdf"),
("Content-Length", str(len(body))),
("Content-Disposition", 'attachment; filename="report.pdf"'),
]
start_response(status, headers)
return [body]
body = b"Go to /download-report to download"
status = "200 OK"
headers = [
("Content-Type", "text/plain; charset=utf-8"),
("Content-Length", str(len(body))),
]
start_response(status, headers)
return [body]
The browser will show a "Save As" dialog when it sees Content-Disposition: attachment.
Consistent Response Structure in APIs
For APIs, consistency helps clients. Many APIs follow patterns such as:
- On success: return a JSON object with data.
- On error: return a JSON object with an error field and possibly a code.
Example pattern:
- Success:
{
"data": {...},
"meta": {...}
}- Error:
{
"error": {
"message": "Description of what went wrong",
"code": "INVALID_INPUT"
}
}Example: Consistent JSON Wrapper
import json
def json_response(start_response, data=None, error=None, status="200 OK"):
if error is not None:
payload = {"error": error}
else:
payload = {"data": data}
body = json.dumps(payload).encode("utf-8")
headers = [
("Content-Type", "application/json; charset=utf-8"),
("Content-Length", str(len(body))),
]
start_response(status, headers)
return [body]
def app(environ, start_response):
path = environ.get("PATH_INFO", "/")
if path == "/user":
# Imagine this data came from a database
user = {"id": 1, "name": "Alice"}
return json_response(start_response, data=user, status="200 OK")
# Unknown path
return json_response(
start_response,
error={"message": "Not found", "code": "NOT_FOUND"},
status="404 Not Found",
)
For JSON APIs, define a consistent response format and use it everywhere.
This makes your backend easier to consume and test.
Summary
In this chapter you learned that:
- A response contains a status line, headers, and an optional body.
- You must choose proper status codes, not always
200. - The Content-Type header must match the body, for example JSON vs HTML vs images.
- You can add headers to control caching, cookies, downloads, redirects, and more.
- JSON is the standard for API responses, and you should return consistent JSON shapes.
- Redirects use 3xx codes and
Locationheader. - Some responses, such as
204 No Content, contain no body.
In later chapters, frameworks such as FastAPI will automate much of this, but understanding these building blocks will help you debug and design better backends.
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!