5.10. JSON
Table of Contents
Why JSON Matters for Backend Developers
JSON, which stands for JavaScript Object Notation, is the most common data format you will handle as a backend developer.
APIs, configuration files, logs, and communication between services often use JSON. In Python backend work with FastAPI or Flask, you will send and receive JSON all the time.
This chapter focuses on how to work with JSON in Python, not on HTTP or REST themselves. You will see how to:
- Represent JSON as Python data
- Convert Python objects to JSON (serialization)
- Convert JSON strings to Python objects (deserialization)
- Read and write JSON files
- Handle common pitfalls like dates and custom classes
JSON Basics vs Python Types
JSON is a text format. It looks a lot like JavaScript objects, but with strict rules. It only supports a small set of data types.
JSON Data Types and Python Equivalents
Here is how JSON types map to Python types:
| JSON type | Example | Python type |
|---|---|---|
| object | {"name": "Alice"} | dict |
| array | [1, 2, 3] | list |
| string | "hello" | str |
| number | 42, 3.14 | int or float |
| boolean | true, false | bool |
| null | null | None |
Some key differences:
- JSON has no tuple, set, bytes, or date type.
- JSON strings must use double quotes
"not single quotes. - JSON keys must be strings, Python dicts allow other types as keys.
Example of valid JSON:
{
"id": 1,
"name": "Alice",
"is_active": true,
"roles": ["user", "admin"],
"profile": {
"age": 30,
"city": "Berlin"
},
"score": null
}The same data as Python:
user = {
"id": 1,
"name": "Alice",
"is_active": True,
"roles": ["user", "admin"],
"profile": {
"age": 30,
"city": "Berlin",
},
"score": None,
}Notice the differences:
true/false/nullin JSON becomeTrue/False/Nonein Python.
The `json` Module in Python
Python has a built-in module called json that lets you convert between JSON and Python types.
Importing it:
import jsonThe most important functions are:
| Direction | From | To | Function |
|---|---|---|---|
| Deserialize JSON to Python | JSON string | Python object | loads |
| Deserialize JSON from file | file object | Python object | load |
| Serialize Python to string | Python object | JSON string | dumps |
| Serialize Python to file | Python object | JSON written | dump |
You will use these four functions all the time.
Converting JSON Strings to Python: `json.loads`
Use json.loads when you already have a JSON string in memory, for example from an HTTP request body.
Basic example:
import json
json_str = '{"id": 1, "name": "Alice", "active": true}'
data = json.loads(json_str)
print(data)
print(type(data))Output:
{'id': 1, 'name': 'Alice', 'active': True}
<class 'dict'>
Now you can work with data as a normal Python dictionary:
print(data["name"]) # Alice
print(data["active"]) # True
print(data.get("email")) # None (key does not exist)
If the JSON is invalid, Python raises a json.JSONDecodeError.
bad_json = "{id: 1}" # invalid, keys must be in quotes
try:
json.loads(bad_json)
except json.JSONDecodeError as e:
print("Failed to parse JSON:", e)You should handle this in your API code, often by returning a 400 Bad Request error.
Converting Python Objects to JSON: `json.dumps`
Use json.dumps to create a JSON string from a Python object so you can send it in an HTTP response or store it.
Basic example:
import json
user = {
"id": 1,
"name": "Alice",
"active": True,
"roles": ["user", "admin"],
"profile": None,
}
json_str = json.dumps(user)
print(json_str)
print(type(json_str))Output:
{"id": 1, "name": "Alice", "active": true, "roles": ["user", "admin"], "profile": null}
<class 'str'>Notice how Python values are converted:
True→trueNone→null- dicts and lists keep their structure
Rule: Only JSON compatible types are allowed by json.dumps: dict, list, str, int, float, bool, and None.
If you pass other types, you must convert them manually or use a custom encoder.
For example, this will fail:
from datetime import datetime
import json
data = {"now": datetime.utcnow()}
json.dumps(data) # TypeError: Object of type datetime is not JSON serializableYou will learn how to handle this kind of custom type later in this chapter.
Pretty Printing JSON
By default json.dumps produces a compact string, which is efficient but hard to read. For debugging and logging, you often want nicely formatted JSON.
Use indent:
import json
user = {
"id": 1,
"name": "Alice",
"active": True,
"roles": ["user", "admin"],
}
print(json.dumps(user, indent=2))Output:
{
"id": 1,
"name": "Alice",
"active": true,
"roles": [
"user",
"admin"
]
}
You can also control key order with sort_keys=True:
print(json.dumps(user, indent=2, sort_keys=True))Output:
{
"active": true,
"id": 1,
"name": "Alice",
"roles": [
"user",
"admin"
]
}Pretty printing is very useful for:
- Debugging API responses
- Logging internal data
- Writing human readable configuration files
Reading JSON from Files: `json.load`
For configuration files, seed data, or test data, you often keep JSON in files.
Example config.json:
{
"debug": true,
"database": {
"host": "localhost",
"port": 5432,
"user": "app_user",
"password": "secret"
}
}
You can read it using json.load:
import json
with open("config.json", "r", encoding="utf-8") as f:
config = json.load(f)
print(config["debug"])
print(config["database"]["host"])Output:
True
localhost
json.load works on a file object, not on a string. It reads the whole file and returns Python data.
Writing JSON to Files: `json.dump`
You can also write Python data to a JSON file using json.dump.
Example:
import json
users = [
{"id": 1, "name": "Alice", "active": True},
{"id": 2, "name": "Bob", "active": False},
]
with open("users.json", "w", encoding="utf-8") as f:
json.dump(users, f, indent=2)
Content of users.json:
[
{
"id": 1,
"name": "Alice",
"active": true
},
{
"id": 2,
"name": "Bob",
"active": false
}
]
Use json.dump when:
- You want to persist data to disk
- You generate JSON files for other systems
- You need test data that tools like Postman can import
Handling Unicode and Special Characters
JSON is text and usually encoded as UTF-8. Many APIs expect Unicode characters properly encoded.
By default, json.dumps escapes non-ASCII characters:
import json
data = {"message": "Olá, мир, مرحبا"}
print(json.dumps(data))Output:
{"message": "Ol\u00e1, \u043c\u0438\u0440, \u0645\u0631\u062d\u0628\u0627"}
If you want actual characters instead of escape sequences, use ensure_ascii=False:
print(json.dumps(data, ensure_ascii=False))Output:
{"message": "Olá, мир, مرحبا"}When writing files with non-ASCII characters:
with open("messages.json", "w", encoding="utf-8") as f:
json.dump(data, f, ensure_ascii=False, indent=2)This is important if humans will read the file or if another system expects real UTF-8 characters.
Dealing with Invalid or Unexpected JSON
Clients may send you malformed JSON or JSON in a shape you do not expect. You must handle this safely.
Catching Parsing Errors
Invalid JSON syntax:
import json
raw_body = '{"id": 1, "name": "Alice"' # missing closing }
try:
payload = json.loads(raw_body)
except json.JSONDecodeError:
# For an API, you would return a 400 status code here
print("Invalid JSON body")In a backend framework, you would typically:
- Catch
JSONDecodeError - Return a 400 response like
{"detail": "Invalid JSON"}
Valid JSON, Wrong Structure
Sometimes JSON is valid but not what you expect, such as missing keys or wrong types.
raw_body = '{"name": 123}'
payload = json.loads(raw_body)
if not isinstance(payload.get("name"), str):
print("Field 'name' must be a string")Later chapters on request validation and Pydantic will show how to handle this in a more robust and automatic way.
Custom Types: Working Around JSON Limitations
Real applications use more data types than JSON supports, especially:
datetimeobjects for timestampsDecimalfor money- Custom classes for your domain models
You must convert them to JSON friendly forms.
Simple Manual Conversion
Convert before calling json.dumps:
from datetime import datetime
import json
user = {
"id": 1,
"name": "Alice",
"created_at": datetime(2024, 1, 1, 12, 0, 0),
}
serializable_user = {
**user,
"created_at": user["created_at"].isoformat(), # "2024-01-01T12:00:00"
}
print(json.dumps(serializable_user, indent=2))Output:
{
"id": 1,
"name": "Alice",
"created_at": "2024-01-01T12:00:00"
}On the way back, you must parse the string again:
from datetime import datetime
import json
json_str = '{"created_at": "2024-01-01T12:00:00"}'
data = json.loads(json_str)
data["created_at"] = datetime.fromisoformat(data["created_at"])Using `default` Parameter in `json.dumps`
You can tell json.dumps how to handle unsupported types using the default parameter.
from datetime import datetime
import json
def default_converter(obj):
if isinstance(obj, datetime):
return obj.isoformat()
# Let json raise TypeError for unknown types
raise TypeError(f"Type {type(obj)} not serializable")
data = {
"id": 1,
"created_at": datetime.utcnow(),
}
json_str = json.dumps(data, default=default_converter, indent=2)
print(json_str)This is flexible, but for complex APIs you will usually use a library such as Pydantic, which handles many of these details for you.
JSON, `dict`, and Deep Structures
JSON can represent nested structures. This maps nicely to Python dicts and lists.
Example JSON:
{
"id": 1,
"name": "Alice",
"orders": [
{
"order_id": 100,
"total": 29.99,
"items": [
{"sku": "A1", "qty": 2},
{"sku": "B2", "qty": 1}
]
}
]
}As Python:
import json
json_str = '''
{
"id": 1,
"name": "Alice",
"orders": [
{
"order_id": 100,
"total": 29.99,
"items": [
{"sku": "A1", "qty": 2},
{"sku": "B2", "qty": 1}
]
}
]
}
'''
user = json.loads(json_str)
print(user["orders"][0]["items"][1]["sku"]) # B2
You navigate nested JSON using combinations of [...] on dicts and lists.
For large nested data structures, you may want to:
- Normalize them into separate database tables
- Define Pydantic models to give structure and validation
- Extract only needed information before processing
JSON and Security Considerations
When handling JSON from clients, always remember:
Never trust client input, even if it is valid JSON.
JSON can:
- Contain very large structures that use a lot of memory
- Have deeply nested objects that cause slow processing
- Be used to try to inject malicious content in other systems
Basic safety tips:
- Limit maximum request body size at your web server or framework level.
- Validate all fields before using them.
- Do not directly insert JSON values into SQL queries. Always use parameterized queries.
- When returning JSON, do not include secrets such as passwords, API keys, or internal tokens.
Later chapters on security and validation will cover these topics in more depth.
Practical Examples for Backend Context
To make JSON usage more concrete, here are a few realistic backend style examples.
Example 1: Parsing a JSON Request Body
Imagine an HTTP POST /users endpoint that receives a JSON body like this:
{
"email": "alice@example.com",
"password": "super-secret",
"age": 30
}In a low level Python web handler you might do something like:
import json
def handle_create_user(request_body: bytes):
try:
payload = json.loads(request_body.decode("utf-8"))
except json.JSONDecodeError:
return {"status": 400, "body": {"error": "Invalid JSON"}}
email = payload.get("email")
password = payload.get("password")
age = payload.get("age")
# Very simplified checks
if not isinstance(email, str) or not isinstance(password, str):
return {"status": 400, "body": {"error": "Invalid fields"}}
# Here you would create user in database
return {"status": 201, "body": {"message": "User created"}}
In frameworks like FastAPI, you normally do not use json.loads directly. The framework parses JSON for you and uses models to validate it. However, understanding json is still essential.
Example 2: Returning JSON in an HTTP Response
Suppose you want to return a JSON response:
import json
def get_user_response(user):
body = json.dumps(user, indent=2)
headers = {
"Content-Type": "application/json; charset=utf-8",
"Content-Length": str(len(body.encode("utf-8"))),
}
return 200, headers, bodyAgain, modern frameworks will handle the headers and encoding, but the core concept is always: convert Python data to JSON string.
Summary
In this chapter you learned how to work with JSON in Python, which is essential for backend development:
- JSON is a text format with a small, well defined set of types.
- Python’s
jsonmodule providesloads/dumpsfor strings andload/dumpfor files. - You must handle invalid JSON with
json.JSONDecodeError. - Use
indent,sort_keys, andensure_asciito control formatting and encoding. - JSON does not support some Python types, such as
datetime, so you must convert them yourself or use custom encoders. - JSON maps naturally to nested
dictandliststructures in Python. - Treat JSON input as untrusted, validate it, and never expose secrets in JSON responses.
These skills will be used heavily in the upcoming chapters about web backends, REST APIs, and FastAPI, where nearly every request and response will involve JSON.
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!