9.2. Relational vs NoSQL Databases
Table of Contents
Why This Comparison Matters
When you build a backend, almost every feature eventually needs to store and read data. Choosing how to store that data is one of your most important decisions.
You will hear two big families mentioned all the time:
- Relational databases (often called SQL databases)
- NoSQL databases
They are not rivals where one is “better” in every way. Each is designed around different ideas and trade‑offs. In this chapter you will:
- Understand the core ideas behind relational and NoSQL databases
- See typical use cases for each
- Learn how to think about which one to use
- Read many concrete examples of data modeling in both styles
You will learn individual technologies like PostgreSQL and Redis in later chapters. Here we focus only on the conceptual comparison.
What Are Relational Databases?
Relational databases store data in tables and use relations between those tables.
A table is like a spreadsheet:
| id | name | |
|---|---|---|
| 1 | Alice Doe | alice@example.com |
| 2 | Bob Roe | bob@example.com |
Each row is a record, each column is a field, and each table describes one type of thing. Relations connect tables, for example "this order belongs to this user."
Relational databases are sometimes called SQL databases, because you usually talk to them with SQL, the Structured Query Language.
Typical relational systems: PostgreSQL, MySQL, MariaDB, SQL Server, Oracle Database.
Key Ideas in Relational Databases
Structured schema
Relational databases require a schema: a predefined structure of your tables.
Example schema for a simple shop:
users table
| column | type | description |
|---|---|---|
| id | integer | primary key |
| text | unique, not null | |
| password | text | hashed password |
orders table
| column | type | description |
|---|---|---|
| id | integer | primary key |
| user_id | integer | foreign key to users.id |
| total_cents | integer | order total in cents |
If you try to insert an order with user_id = 999 and there is no user with id = 999, the database will reject it if you defined a foreign key.
This strictness helps keep your data consistent.
Relationships
Relational databases are built around relationships:
- One user can have many orders
- One order can have many items
- One product can belong to many categories
These are represented by keys and join tables. You will learn the details in the rest of the Databases and SQL chapters. Here, remember:
Relational databases are optimized for data with clear structure and well defined relationships.
ACID guarantees
Relational databases usually provide ACID properties for transactions:
- Atomicity, all or nothing
- Consistency, rules are always respected
- Isolation, concurrent operations do not conflict incorrectly
- Durability, once committed, data survives crashes
You do not need to memorize ACID now, you will see it in a separate chapter. Here it is enough to know that relational databases are very good at reliable multi step operations such as:
- Transfer money: subtract from one account and add to another
- Place an order: create order, create order items, update stock
What Are NoSQL Databases?
"NoSQL" is an umbrella term for databases that do not primarily use the traditional relational model with SQL.
Different NoSQL databases look very different. Common types:
| Type | Example systems | Main idea |
|---|---|---|
| Document store | MongoDB, CouchDB | Store flexible JSON-like documents |
| Key value store | Redis, Riak | Store values accessible by a simple key |
| Wide column store | Cassandra, HBase | Tables with flexible columns for huge scale |
| Graph database | Neo4j, ArangoDB | Focus on relationships as a graph |
So "NoSQL" does not mean one single technology. It means "not the classic SQL relational model."
Common traits many NoSQL systems share:
- More flexible schemas
- Often designed for horizontal scaling across many servers
- Sometimes give up some ACID guarantees to get extreme performance or availability
Key Ideas in NoSQL Databases
Flexible or schema-less data
Most NoSQL databases let you store documents with different fields in the same collection.
Example in a document database:
Collection: products
{
"id": 1,
"name": "Simple T-Shirt",
"price": 19.99,
"sizes": ["S", "M", "L"]
}and another document:
{
"id": 2,
"name": "Laptop",
"price": 1299.00,
"specs": {
"cpu": "i7",
"ram_gb": 16
},
"warranty_years": 2
}
Both are products, but they do not have the same fields. That is fine in many NoSQL databases. In a relational database, you would usually design the schema to handle all product fields ahead of time, or create multiple tables.
This flexibility is powerful, but it also means you must manage consistency yourself in your application code.
Data as documents or aggregates
In many NoSQL systems you often store all data that you need together in a single document, instead of splitting it across many tables.
For example, an order document in a document database could look like:
{
"id": 123,
"user": {
"id": 5,
"email": "alice@example.com"
},
"items": [
{"product_id": 10, "name": "Mouse", "price": 15.99, "quantity": 1},
{"product_id": 11, "name": "Keyboard", "price": 39.99, "quantity": 1}
],
"total": 55.98
}Everything about the order is embedded inside one document. You can load the whole order with one query, without joins.
Different priorities than SQL databases
Many NoSQL databases aim for at least some of these:
- Easier horizontal scaling across many machines
- High write throughput
- High availability even when some nodes fail
- Eventual consistency instead of strict immediate consistency
Not all NoSQL systems do all of these, but they often trade some relational features to make large scale problems easier.
Modeling Data: Relational vs NoSQL
To understand the differences better, let us look at very concrete examples.
Example 1: Blog with posts and comments
You are building a blog. Each post has many comments. You want to list a post with its comments.
Relational modeling
You might have:
posts table
| id | title | body |
|---|---|---|
| 1 | Hello world | ... |
comments table
| id | post_id | author | text |
|---|---|---|---|
| 1 | 1 | Alice | Nice post! |
| 2 | 1 | Bob | I agree |
post_idincommentsis a foreign key toposts.id- To fetch a post and comments, you might run:
SELECT * FROM posts WHERE id = 1;
SELECT * FROM comments WHERE post_id = 1;or a join:
SELECT p.id, p.title, c.author, c.text
FROM posts p
LEFT JOIN comments c ON c.post_id = p.id
WHERE p.id = 1;Relationships are normalized, each concept has its own table.
NoSQL modeling (document database)
You might have a single posts collection. Each document has its comments embedded.
{
"id": 1,
"title": "Hello world",
"body": "...",
"comments": [
{"author": "Alice", "text": "Nice post!"},
{"author": "Bob", "text": "I agree"}
]
}To load a post and comments you do one query for that document.
Trade offs:
- Relational
- Easier to search all comments by a specific user, because comments are in their own table.
- Good for very large numbers of comments or when comments are reused.
- Document style
- Very easy to load a post with its comments.
- Good when comments only matter together with the post, and the number of comments is not too extreme.
Example 2: User profiles that change over time
You have users with basic info, and over time you add new profile fields such as "Twitter handle", "favorite color", etc.
Relational approach
You usually update the schema:
- Start with:
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email TEXT NOT NULL,
password TEXT NOT NULL
);- Later add columns:
ALTER TABLE users ADD COLUMN twitter_handle TEXT;
ALTER TABLE users ADD COLUMN favorite_color TEXT;If you suddenly add many optional fields, your table might become wide but still structured.
NoSQL document approach
You just start storing new fields when they appear. No migration required.
Before:
{
"id": 1,
"email": "alice@example.com",
"password": "..."
}After:
{
"id": 1,
"email": "alice@example.com",
"password": "...",
"twitter_handle": "@alice",
"favorite_color": "blue"
}Old documents without these fields still exist. Your code must handle missing fields.
Trade offs:
- Relational:
- More work when you change the schema, but the structure is always explicit.
- NoSQL:
- Easy to add fields, but you must be careful in code when reading older documents.
When Relational Databases Shine
Relational databases are usually a great default choice. They shine when:
1. Your data has strong structure and relationships
Use a relational database when:
- You have clear entities such as Users, Orders, Products, Payments
- There are many relationships such as "user has many orders" or "product belongs to category"
- You need to enforce consistency, such as "every order must belong to an existing user"
Example: E commerce system
- Users, products, categories, orders, order items, stock levels
- You frequently join data, such as listing all orders with user info and product details
Relational databases are designed for this.
2. You need strong consistency
Banking, billing, inventory or any domain where mistakes are expensive.
Example:
- Transfer $100 from account A to account B
- You must never end up in a state where money disappeared or appeared from nowhere
Relational databases, with ACID transactions, make this much easier.
3. You need powerful ad hoc queries
Relational databases are very strong when you often need new queries that were not planned.
Example:
- "Show me all users who ordered more than 3 items last month and spent more than 200 dollars"
- "Show me the top 10 products in each category by revenue"
SQL is very expressive for these questions, and the structure of the data fits the SQL model.
When NoSQL Databases Shine
NoSQL is not "better SQL". It is for different needs.
1. Flexible and evolving data
When your data structure changes often, or each record can look quite different, a document database can be simpler.
Example: User generated content
- Users can add any number of custom fields to their profiles.
- Each product can have different attributes, especially in marketplaces.
In these cases, handling a fixed relational schema can become painful. A document database lets you store what you have without constant migrations.
2. Large scale, high throughput workloads
Some NoSQL systems were built to handle massive scale with many servers.
Example: Logging or analytics events
You collect millions of events per minute, such as:
{
"user_id": 123,
"path": "/products/10",
"duration_ms": 250
}You might choose a system designed for huge write rates and efficient storage of time series or event data.
3. Simple key based access or caching
Key value stores such as Redis are great when:
- You mostly get and set data by a simple key
- Data is often ephemeral or cached
- You need very fast reads and writes in memory
Example:
- Cache user sessions by session id
- Cache the result of an expensive database query
- Store rate limiting counters for each IP address
You typically still use a relational database as the source of truth, and use Redis as a secondary store to speed things up.
4. Graph data
If your domain is naturally a graph, such as:
- Users follow users
- People know people
- Devices connect to devices
then a graph database might be easier to use, because relationships are first class citizens in the model.
Comparing Relational and NoSQL: A Summary Table
| Aspect | Relational (SQL) | NoSQL |
|---|---|---|
| Data model | Tables, rows, columns | Documents, key value, wide column, graph, etc. |
| Schema | Fixed, defined ahead of time | Often flexible or schema less |
| Relationships | First class via foreign keys and joins | Often embedded or handled in application |
| Query language | SQL | Varies, often API specific |
| Transactions & ACID | Strong support | Varies, some limited or different models |
| Best for | Structured, relational data | Flexible, semi structured, large scale scenarios |
| Horizontal scaling | Possible, but more complex | Many systems designed with this in mind |
| Typical uses | E commerce, banking, CRM, traditional apps | Logs, analytics, caching, flexible content, graphs |
You almost never pick "relational vs NoSQL" as an absolute choice for a whole company. It is common to use both, each where it fits best.
Thinking About Trade Offs
When choosing how to store data in a new backend, ask yourself some questions.
How stable is the data structure?
- If you know your entities and relationships are stable, relational is often easier.
- If fields change frequently or each record can be very different, a document database might be better.
How important is strict consistency?
- Money, inventory, permissions usually require strong consistency. Relational databases fit well.
- Logs, metrics, temporary caches can tolerate eventual consistency. NoSQL can work very well here.
Do you need many complex queries?
- If you expect many ad hoc reports and joins, SQL is powerful.
- If you mostly read by key or simple filters and rarely join, NoSQL can be enough.
How big and how fast?
Scaling is a complex topic. Many relational databases scale very far, especially with good indexes and hardware. NoSQL systems can scale horizontally more easily in some scenarios, but they often add complexity somewhere else.
Practical Patterns in Real Backends
In real backend systems, you rarely use only one storage technology for everything.
Common patterns:
- Relational as the main system of record, NoSQL as helper
- PostgreSQL for core business data
- Redis as cache and for sessions
- Maybe a document store for some flexible content
- Event data vs core data
- Relational database for orders, users, etc.
- NoSQL or time series database for huge volumes of analytics events
Example architecture for an e commerce backend:
| Data type | Suggested storage |
|---|---|
| Users, products | Relational database (PostgreSQL) |
| Orders, payments | Relational database with transactions |
| Inventory snapshots | Relational or specialized store |
| User sessions | Redis (key value store) |
| Page view events | NoSQL or log oriented database |
| Cache of product pages | Redis cache |
You will learn how to integrate these pieces in later chapters, including PostgreSQL, Redis, caching, and background processing.
How To Practice This Knowledge
You do not need to become an expert in all types right now. As a beginner backend developer:
- Start with relational databases
- Learn tables, relationships, and SQL.
- Practice modeling a small application, such as a to do list or simple blog.
- Then explore NoSQL for specific problems
- Use Redis to cache some expensive SQL queries.
- Try storing some flexible JSON documents in a document database and compare the experience.
- Compare designs intentionally
For a simple feature like "user posts with comments": - Design it as relational tables.
- Design it as a document model.
- Write down what feels easier for each type of query.
By doing this a few times, you will develop intuition for when relational or NoSQL approaches fit best.
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!