11.10. JSON Data
Table of Contents
Why JSON Matters in PostgreSQL
Backend APIs frequently send and receive JSON. PostgreSQL has first‑class support for JSON, which lets you:
- Store flexible or semi‑structured data.
- Avoid complex migrations for small schema changes.
- Work with data similar to what your API already consumes or produces.
PostgreSQL actually has two JSON related types: json and jsonb. Understanding them and the related functions is key to using JSON effectively.
JSON vs JSONB
PostgreSQL supports:
jsontypejsonbtype (binary JSON)
They look similar at first, but behave differently internally and in queries.
Core differences
| Feature | json | jsonb |
|---|---|---|
| Storage format | Text | Binary, parsed |
| Validation on insert | Yes, must be valid JSON | Yes, must be valid JSON |
| Preserves whitespace | Yes | No |
| Preserves key order | Yes | No |
| Duplicate keys | Preserved as‑is | Last key wins |
| Indexing support | Limited | Rich support (GIN, etc.) |
| Query performance (operators) | Slower, re‑parses text | Faster, pre‑parsed |
| Recommended for new applications | Rarely | Almost always |
Rule: For backend applications, use jsonb by default unless you have a very specific reason to preserve original JSON formatting exactly.
Storing JSON Data
You can define columns of type json or jsonb in your tables.
Creating a table with JSONB
CREATE TABLE products (
id SERIAL PRIMARY KEY,
name TEXT NOT NULL,
attributes JSONB, -- flexible product attributes
metadata JSONB -- extra info, logs, tags, etc.
);Inserting data:
INSERT INTO products (name, attributes, metadata)
VALUES (
'T‑Shirt',
'{ "color": "blue", "size": "M", "in_stock": true }',
'{
"tags": ["clothing", "summer"],
"created_by": "admin",
"dimensions": { "width": 40, "height": 60 }
}'
);PostgreSQL validates JSON on insert. If you insert invalid JSON, you get an error:
INSERT INTO products (name, attributes)
VALUES ('Broken', '{color: blue}'); -- invalid JSON, keys must be quotedThis will fail because JSON requires double quotes around keys and string values.
Using parameterized queries in code
In a Python backend using psycopg2 or asyncpg, you pass JSON as native structures:
cur.execute(
"""
INSERT INTO products (name, attributes)
VALUES (%s, %s)
RETURNING id
""",
(
"Sneakers",
{
"color": "white",
"size": 42,
"in_stock": True,
},
)
)
The driver converts the Python dict into JSONB automatically if the column is jsonb.
Basic JSONB Operations
PostgreSQL provides special operators for JSON/JSONB. Many are used constantly in backend queries.
Access operators: `->`, `->>`, `#>`, `#>>`
| Operator | Returns | Usage example |
|---|---|---|
-> | JSON / JSONB | Access field as JSON |
->> | text | Access field as text |
#> | JSON / JSONB | Nested path access as JSON |
#>> | text | Nested path access as text |
Assume:
SELECT attributes
FROM products
WHERE name = 'T‑Shirt';Returns:
{ "color": "blue", "size": "M", "in_stock": true }Example 1: Get a top level key
SELECT
attributes->'color' AS color_json, -- JSON
attributes->>'color' AS color_text -- text
FROM products;Result:
| color_json | color_text |
|---|---|
"blue" | blue |
Example 2: Nested keys
Given:
SELECT metadata FROM products WHERE name = 'T‑Shirt';{
"tags": ["clothing", "summer"],
"created_by": "admin",
"dimensions": { "width": 40, "height": 60 }
}Use path operators:
SELECT
metadata->'dimensions'->'width' AS width_json,
metadata->'dimensions'->>'width' AS width_text,
metadata#>'{dimensions,width}' AS width_json2,
metadata#>>'{dimensions,width}' AS width_text2
FROM products;
'{dimensions,width}' represents the path ["dimensions", "width"].
Querying JSONB: Containment and Existence
These operators are extremely useful for filtering records by JSON values.
Containment: `@>`
jsonb @> jsonb is true if the left JSON contains the right JSON.
For example, products whose attributes include "color": "blue":
SELECT name, attributes
FROM products
WHERE attributes @> '{"color": "blue"}';This works even if there are additional keys.
Containment for arrays:
SELECT name, metadata
FROM products
WHERE metadata->'tags' @> '["summer"]';
This returns rows where tags array contains "summer".
Existence: `?`, `?|`, `?&`
| Operator | Description | |
|---|---|---|
? | Does key (or string in array) exist? | |
| `? | ` | Does any of these keys/strings exist? |
?& | Do all of these keys/strings exist? |
Assume attributes like:
{ "color": "blue", "size": "M", "in_stock": true }Check if key exists:
SELECT name
FROM products
WHERE attributes ? 'color';Check if any of several keys exist:
SELECT name
FROM products
WHERE attributes ?| array['size', 'weight'];Check if all keys exist:
SELECT name
FROM products
WHERE attributes ?& array['color', 'size'];These also work on JSON arrays of strings.
Updating JSONB
You often need to update only part of a JSON document without replacing the whole value.
Concatenation and merge: `||`
jsonb || jsonb merges objects. Right side overwrites conflicts.
UPDATE products
SET attributes = attributes || '{"color": "red"}'
WHERE name = 'T‑Shirt';
If attributes was:
{ "color": "blue", "size": "M", "in_stock": true }After update:
{ "color": "red", "size": "M", "in_stock": true }You can also add new keys:
UPDATE products
SET attributes = attributes || '{"material": "cotton"}'
WHERE name = 'T‑Shirt';Result:
{ "color": "red", "size": "M", "in_stock": true, "material": "cotton" }Remove keys: `-` and `#-`
| Operator | Description |
|---|---|
- | Remove top level key or array element |
#- | Remove nested key or element by path |
Remove a top level key:
UPDATE products
SET attributes = attributes - 'size'
WHERE name = 'T‑Shirt';Remove multiple keys:
UPDATE products
SET attributes = attributes - array['size', 'in_stock']
WHERE name = 'T‑Shirt';Remove a nested key:
UPDATE products
SET metadata = metadata #- '{dimensions,width}'
WHERE name = 'T‑Shirt';
If dimensions was:
{ "width": 40, "height": 60 }after this, it becomes:
{ "height": 60 }JSONB Functions You Will Use Often
PostgreSQL has many JSON functions. Here are some that are very helpful in backend work.
`jsonb_build_object` and `jsonb_build_array`
These build JSONB from SQL values.
SELECT jsonb_build_object(
'id', id,
'name', name,
'attributes', attributes
) AS product_json
FROM products;Example result:
{
"id": 1,
"name": "T‑Shirt",
"attributes": { "color": "red", "material": "cotton" }
}You can send this directly to an API client.
Build an array:
SELECT jsonb_build_array(1, 'two', true, jsonb_build_object('a', 1));Result:
[1, "two", true, { "a": 1 }]`to_jsonb`
Convert SQL values and rows to JSONB.
Simple value:
SELECT to_jsonb(42); -- 42
SELECT to_jsonb('hello'); -- "hello"Whole row:
SELECT to_jsonb(products)
FROM products
WHERE id = 1;This converts the entire row (all columns) to a JSONB object.
Aggregating to JSON: `json_agg`, `jsonb_agg`
For building JSON arrays of rows:
SELECT jsonb_agg(to_jsonb(p))
FROM products AS p;Result:
[
{ "id": 1, "name": "T‑Shirt", "attributes": { ... } },
{ "id": 2, "name": "Sneakers", "attributes": { ... } }
]This is perfect when your backend needs to send a JSON array of objects.
Another common REST API pattern:
SELECT jsonb_build_object(
'total', COUNT(*),
'items', jsonb_agg(to_jsonb(p))
)
FROM products AS p;Result:
{
"total": 2,
"items": [
{ "id": 1, "name": "T‑Shirt", ... },
{ "id": 2, "name": "Sneakers", ... }
]
}Indexing JSONB for Performance
JSONB queries using @>, ?, etc can be slow without indexes.
GIN indexes
For JSONB you typically use GIN indexes.
Create a GIN index on a JSONB column:
CREATE INDEX products_attributes_gin_idx
ON products
USING GIN (attributes);This helps for:
SELECT *
FROM products
WHERE attributes @> '{"color": "blue"}';or
SELECT *
FROM products
WHERE attributes ? 'color';If you often query specific paths, you can index expressions.
For example, filter by attributes->>'size':
CREATE INDEX products_attributes_size_idx
ON products ((attributes->>'size'));Now this query can use an index:
SELECT *
FROM products
WHERE attributes->>'size' = 'M';Rule: If you query JSONB columns frequently, add appropriate GIN or expression indexes. Without them, JSON filters can become very slow on large tables.
When to Use JSONB vs Normal Columns
JSONB is powerful, but not always the right tool. Think of it as a complement to relational tables, not a full replacement.
Good use cases
- Optional or rarely used fields that vary by record.
Example:attributesfor products where each product type has different extra data. - External, loosely structured data from third party APIs, logs, or tracking events.
- Temporary or experimental fields during early development when the schema is not stable.
- Configuration blobs that are small, per record, and not heavily queried.
Poor use cases
- Core entities with fixed structure, like
users(id, email, password_hash). - Data that you frequently filter, sort, or join on, where strong relational modeling is better.
- Very large JSON documents attached to each row, which can be expensive to update.
A common hybrid approach:
CREATE TABLE orders (
id SERIAL PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users(id),
status TEXT NOT NULL,
total_amount NUMERIC(10,2) NOT NULL,
details JSONB -- line items, extra info
);
Core fields are normal columns, the flexible remainder lives in details.
Practical Examples for Backend Work
Example 1: Filtering by JSON attribute
You have an API endpoint:
GET /products?color=blue&size=MSQL using JSONB:
SELECT *
FROM products
WHERE attributes @> format('{"color": "%s", "size": "%s"}', 'blue', 'M')::jsonb;In real backend code, use parameterized queries instead of string formatting.
Example 2: Sorting by JSON field
Sort products by nested dimensions.height:
SELECT name, metadata->'dimensions'->>'height' AS height
FROM products
ORDER BY (metadata->'dimensions'->>'height')::INTEGER;
Note the cast to INTEGER to sort numerically instead of lexicographically.
Example 3: Partial update from API
You receive a PATCH request:
{
"attributes": {
"color": "green",
"in_stock": false
}
}
You want to merge this into existing attributes:
UPDATE products
SET attributes = attributes || '{"color": "green", "in_stock": false}'
WHERE id = 1;In application code, you would build the JSON dynamically from the request body.
Summary
- Use
jsonbin PostgreSQL to store flexible, semi structured data in your backend. - Learn the key operators:
->,->>,#>,#>>for access.@>for containment.?,?|,?&for existence.||,-,#-for updates and deletions.- Use
jsonb_build_object,jsonb_agg, andto_jsonbto build JSON responses directly in SQL. - Add GIN and expression indexes for fast JSONB queries.
- Combine relational columns for core data and JSONB for flexible attributes.
With these tools, you can design PostgreSQL schemas that work naturally with JSON based web APIs while still keeping good performance and structure.
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!