9.1. Introduction to Databases
Table of Contents
Why Backends Need Databases
When you build a backend, you almost always need a place to store data so you can use it later. A database is that place.
Some typical things a backend stores:
- Users and passwords (securely hashed)
- Blog posts, comments, likes
- Products, orders, payments
- Logs and metrics
- Configuration and feature flags
You could store data in files like data.json, but this quickly becomes a problem:
- How do you search efficiently?
- How do you update one item without corrupting the file?
- How do you handle multiple users writing at the same time?
- How do you prevent data loss if your app crashes during a write?
Databases solve these problems. They are specialized systems designed to:
- Store data safely and reliably
- Answer questions (queries) quickly
- Handle many users at the same time
- Keep data consistent and recoverable
Key idea: A database is a system that stores data in a structured way, lets many users and applications access it at the same time, and provides tools to query, update, and protect that data.
In backend development, you usually do not build your own database from scratch. You use an existing database engine such as PostgreSQL, MySQL, or MongoDB.
Database vs File Storage
Many beginners wonder: “Why not just use files?”
Simple file storage example
Imagine a simple blog application that stores posts in a JSON file:
[
{
"id": 1,
"title": "Hello world",
"content": "My first post",
"author": "alice",
"created_at": "2026-08-27T12:00:00Z"
},
{
"id": 2,
"title": "Second post",
"content": "More content",
"author": "bob",
"created_at": "2026-08-27T13:00:00Z"
}
]
If you want to find all posts by alice, your backend would:
- Read the whole file into memory.
- Loop over all items.
- Filter items where
author == "alice".
This is fine for 10 posts, maybe 1000 posts, but not for millions.
File storage problems
With pure file storage, you must handle everything yourself:
- Searching
- You must write code to scan data for every query.
- There are no built-in indexes to speed up lookups.
- Updating a record
- You must read the file, modify the data in memory, then write the whole file back.
- A crash during write can leave the file corrupted.
- Concurrent access
- Two users updating at the same time can overwrite each other’s changes.
- You need to implement locking or versioning by hand.
- Backups and recovery
- You must create backup copies manually.
- Restoring from partial or corrupted files is tricky.
How databases improve this
Databases provide:
- Query language: For example SQL, to express “Give me all posts by alice created after yesterday.”
- Indexes: Special data structures that make lookups fast.
- Transactions: Group operations that either all succeed or all fail.
- Concurrency control: Multiple clients can read and write safely.
- Backups and replication: Built-in or supported tools to copy and restore data.
So you, as a backend developer, can focus on business logic, not on reinventing safe storage.
Types of Data and Databases
Different applications work with different types of data, and different databases are optimized for different styles.
Structured vs semi-structured vs unstructured data
| Type | Example | Typical storage |
|---|---|---|
| Structured | Users with name, email, created_at | Relational databases (PostgreSQL, MySQL) |
| Semi-structured | JSON API responses, settings documents | Document databases (MongoDB), JSON columns |
| Unstructured | Images, videos, PDFs | Object storage (S3), file storage |
As a backend developer you will often:
- Store structured data in a relational database.
- Store large files in an object storage service.
- Maybe store semi-structured data in a document store or in JSON columns of a relational DB.
This chapter focuses on the core database concepts, not on choosing a database yet.
Core Concepts: Database, Table, Row, Column
At a very high level, a typical relational database system has:
- A database server: The program that runs (for example PostgreSQL).
- One or more databases: Logical containers inside the server.
- Inside each database, you have tables.
- Tables contain rows (also called records), and each row has columns (also called fields).
You will study tables, rows, and columns more deeply in later chapters. For now, you only need an intuitive picture.
Simple example
Imagine a database for a task management app. It might have tables like:
userstasksprojects
The users table could look like this conceptually:
| id | name | created_at | |
|---|---|---|---|
| 1 | alice@example.com | Alice | 2026-08-27 10:00:00 UTC |
| 2 | bob@example.com | Bob | 2026-08-27 10:05:00 UTC |
In code, this concept maps to a Python dictionary or JSON, but in a database it is a row in a table.
Visual analogy
Think of:
- A table as a spreadsheet sheet.
- Columns as the vertical labeled sections like
email,name. - Rows as individual entries like “Alice”.
But databases are much more powerful than spreadsheets:
- They can handle millions or billions of rows.
- They can be accessed by many clients simultaneously.
- They have transactions, indexing, and query languages.
How Backends Talk to Databases
Your backend application is usually a separate program that connects to a database server over the network.
Connection basics
To connect, the backend needs:
- Host: Where the database server runs, for example
localhostordb.example.com. - Port: A number indicating where the database listens, for example
5432for PostgreSQL. - Database name: For example
task_manager. - User and password: For authentication.
In Python, a very simplified PostgreSQL connection might look like:
import psycopg2
conn = psycopg2.connect(
host="localhost",
port=5432,
dbname="task_manager",
user="app_user",
password="secret-password"
)You will normally hide these values in environment variables, not hard-code them, but this shows the idea.
Once connected, the backend can:
- Send a query to read data.
- Send a command to insert, update, or delete data.
Query example
Imagine we want all tasks for user with ID 1:
cursor = conn.cursor()
cursor.execute("SELECT id, title, completed FROM tasks WHERE user_id = %s", (1,))
rows = cursor.fetchall()The idea is:
- The backend forms a query.
- The database parses and executes it.
- The database returns the results to the backend.
You will learn the SQL language and ORMs later. At this stage just remember: the backend talks to the database using a protocol and a query language, most often SQL.
What Databases Do for Your Backend
Databases offer several important properties that directly affect how you design your backend.
Reliability and durability
If your server restarts, you do not want to lose all data.
Databases typically guarantee that once data is committed, it will survive crashes and restarts, as long as disk storage is intact.
For example:
- Your user registers.
- You store the user in the database.
- The server crashes right after.
- When you restart the server, the user is still there.
Consistency and constraints
Databases can enforce rules about your data:
- Emails must be unique.
- A task must belong to a valid user.
- A column cannot be empty.
These rules are called constraints and help keep your data valid. You will study them in detail in a separate chapter.
Your backend can rely on the database to prevent certain invalid states, which simplifies your code.
Concurrency
Many clients access your backend at the same time. They might:
- Create users at the same moment.
- Update the same task simultaneously.
- Read data while others write.
The database manages concurrency so that operations do not corrupt data. For example, it ensures that:
- Two users inserting a record at the same time both succeed.
- Conflicting updates are handled according to rules (like locking or versioning).
As a backend developer, you need to understand that:
- Databases can handle multiple connections at once.
- But there are limits on how many connections and queries they can handle efficiently.
- You may use connection pools to reuse connections.
Transactions
A transaction groups a set of operations into a single logical unit. Either all operations succeed, or none of them do.
Example:
- Step 1: Create an order in the
orderstable. - Step 2: Decrease product stock in
productstable. - Step 3: Insert order items in
order_itemstable.
You want either all three steps to succeed, or if any fails, you want none of them to be saved, so your data does not get into a broken state.
In Python pseudocode:
try:
cursor.execute("BEGIN")
cursor.execute("INSERT INTO orders (...) VALUES (...);")
cursor.execute("UPDATE products SET stock = stock - 1 WHERE id = ...;")
cursor.execute("INSERT INTO order_items (...) VALUES (...);")
cursor.execute("COMMIT")
except Exception:
cursor.execute("ROLLBACK")
raiseYou will learn more about transactions and ACID properties in later chapters, but the key point is that databases can group operations safely.
Important: Use transactions when you need multiple related changes to be applied together, so your data never ends up in a half-updated state.
Logical vs Physical View of Data
As a backend developer, you mostly work with the logical view of the data, not how bytes are stored on disk.
Logical view
Examples of questions you ask:
- “What tables do I need?”
- “Which columns should be in this table?”
- “How do I link users to tasks?”
You think of data in terms of:
- Tables and columns.
- Relationships between tables.
- Queries that answer business questions.
Physical view
The database internally deals with:
- How rows are stored on disk.
- Which indexes to use for a query.
- How to cache frequently used data in memory.
- How to write logs for crash recovery.
You rarely control these details directly, although you might tune them for performance later.
The separation is helpful:
- You focus on modeling your business problem.
- The database focuses on storage and performance.
Examples of Common Backend Data Models
To make the idea of a database concrete, here are some simple models you might build as a beginner backend developer.
User and task model
For a task management API, you might have:
users table
| Column | Type | Notes |
|---|---|---|
| id | integer | Unique identifier |
| text | Must be unique | |
| password | text | Hashed password |
| created_at | timestamp | When the user registered |
tasks table
| Column | Type | Notes |
|---|---|---|
| id | integer | Unique identifier |
| user_id | integer | Which user owns the task |
| title | text | Task title |
| completed | boolean | True or false |
| created_at | timestamp | When the task was created |
Your backend would:
- Create a new row in
userswhen someone registers. - Create new rows in
taskswhen they add tasks. - Query
taskswhereuser_idis the current user to list their tasks.
You will learn more about relationships like user_id in dedicated chapters.
Blog model
For a simple blog, you might design:
userstable, similar to the previous example.poststable withauthor_id,title,content,published_at.commentstable withpost_id,author_id,content.
Your backend:
- Uses routes like
GET /poststo read from thepoststable. - Uses
POST /poststo insert intoposts. - Uses
GET /posts/{id}/commentsto query thecommentstable.
These models show how database tables map naturally to backend API endpoints.
How Databases Fit into a Backend System
It is useful to see where the database sits in the whole architecture.
A typical web backend has:
- Client
Web browser, mobile app, or another service. - Backend application
Your code, for example a FastAPI app running on a server. - Database server
PostgreSQL, MySQL, or another database that stores persistent data.
Communication flow:
- Client sends a request to your backend, for example
POST /tasks. - Backend receives the request, validates input.
- Backend sends a query to the database to insert a new task row.
- Database stores the data and returns a result.
- Backend sends a response back to the client.
In diagram form:
| Step | Actor | Action |
|---|---|---|
| 1 | Client | Sends HTTP request |
| 2 | Backend | Processes request |
| 3 | Backend → DB | Executes query (insert / select) |
| 4 | DB → Backend | Returns rows / success status |
| 5 | Backend → Client | Sends HTTP response |
The database is a separate component. It might run:
- On the same machine as the backend (development).
- On a dedicated server or cloud service (production).
Choosing a Database as a Beginner
You will later study the differences between relational and NoSQL databases. For now, it is useful to know what beginners usually start with.
Most backend tutorials and real-world APIs use:
- A relational database, for example PostgreSQL.
- SQL as the query language.
- An ORM (Object Relational Mapper) to interact with the database using code instead of writing raw SQL everywhere.
Common beginner choices:
| Purpose | Popular choice |
|---|---|
| Main application data | PostgreSQL |
| Simple dev / experiments | SQLite |
| Caching / ephemeral data | Redis |
For this course, you will usually see PostgreSQL as the main example database.
Practical advice: As a beginner backend developer, focus on learning one relational database (like PostgreSQL) and SQL well before exploring many other database types.
Summary
In this chapter you learned:
- What a database is and why backends need one.
- Why simple file storage is not enough for real applications.
- Basic concepts like database, table, row, column.
- How backends connect to and query databases.
- The roles of reliability, consistency, concurrency, and transactions.
- How data models for users, tasks, posts, and comments look in a database.
- Where the database fits in the overall backend architecture.
- Why relational databases, especially PostgreSQL, are a solid starting point.
In the next chapters you will dive deeper into database types, structures, relationships, and how to design efficient and reliable schemas for your backend applications.
Views: 0
Where to Move
Move chapter:
- ☰ 1. Introduction to Backend Development
- ☰ 1.1. What Is Backend Development?
- ☰ 1.2. Frontend vs Backend
- ☰ 1.3. How Web Applications Work
- ☰ 1.4. Client-Server Architecture
- ☰ 1.5. Request-Response Cycle
- ☰ 1.6. Static vs Dynamic Websites
- ☰ 1.7. Backend Developer Responsibilities
- ☰ 1.8. Backend Development Roadmap
-
- ☰ 2. How the Web Works
- ☰ 2.1. The Internet and the Web
- ☰ 2.2. IP Addresses
- ☰ 2.3. Domain Names
- ☰ 2.4. DNS
- ☰ 2.5. Ports
- ☰ 2.6. TCP/IP Basics
- ☰ 2.7. HTTP and HTTPS
- ☰ 2.8. HTTP Requests
- ☰ 2.9. HTTP Responses
- ☰ 2.10. HTTP Methods
- ☰ 2.11. HTTP Status Codes
- ☰ 2.12. HTTP Headers
- ☰ 2.13. Cookies
- ☰ 2.14. Sessions
- ☰ 2.15. What Happens When You Enter a URL?
-
- ☰ 3. Development Environment
- ☰ 3.1. Choosing an Operating System
- ☰ 3.2. Linux Basics for Backend Developers
- ☰ 3.3. Command Line Basics
- ☰ 3.4. Environment Variables
- ☰ 3.5. Installing Development Tools
- ☰ 3.6. Code Editors and IDEs
- ☰ 3.7. Git
- ☰ 3.8. GitHub and GitLab
- ☰ 3.9. Creating Your First Repository
- ☰ 3.10. Branches and Commits
- ☰ 3.11. Basic Git Workflow
-
- ☰ 4. Programming Fundamentals
- ☰ 4.1. Variables and Data Types
- ☰ 4.2. Operators
- ☰ 4.3. Conditions
- ☰ 4.4. Loops
- ☰ 4.5. Functions
- ☰ 4.6. Data Structures
- ☰ 4.7. Error Handling
- ☰ 4.8. Modules and Packages
- ☰ 4.9. File Handling
- ☰ 4.10. Object-Oriented Programming
- ☰ 4.11. Classes and Objects
- ☰ 4.12. Inheritance and Composition
- ☰ 4.13. Clean Code Principles
-
- ☰ 5. Python for Backend Development
- ☰ 5.1. Introduction to Python
- ☰ 5.2. Installing Python
- ☰ 5.3. Virtual Environments
- ☰ 5.4. pip and Package Management
- ☰ 5.5. Python Project Structure
- ☰ 5.6. Functions and Type Hints
- ☰ 5.7. Classes and Dataclasses
- ☰ 5.8. Exceptions
- ☰ 5.9. Working with Files
- ☰ 5.9.1. File Downloads
- ☰ 5.9.2. File Validation
- ☰ 5.9.3. Image Uploads
- ☰ 5.9.4. Local File Storage
- ☰ 5.9.5. Object Storage
- ☰ 5.9.6. S3-Compatible Storage
- ☰ 5.9.7. Presigned URLs
- ☰ 5.9.8. Secure File Handling
-
- ☰ 5.10. JSON
- ☰ 5.11. Date and Time
- ☰ 5.12. Logging
- ☰ 5.13. Configuration
- ☰ 5.14. Environment Variables
- ☰ 5.15. Async Programming
- ☰ 5.16. Python Backend Best Practices
-
- ☰ 6. Introduction to Web Backends
- ☰ 6.1. Building a Simple Web Server
- ☰ 6.2. Routing
- ☰ 6.3. URL Parameters
- ☰ 6.4. Query Parameters
- ☰ 6.5. Request Bodies
- ☰ 6.6. Form Data
- ☰ 6.7. JSON Requests
- ☰ 6.8. Returning Responses
- ☰ 6.9. Templates
- ☰ 6.10. Static Files
- ☰ 6.11. Middleware
- ☰ 6.12. Application Configuration
-
- ☰ 7. REST APIs
- ☰ 7.1. What Is an API?
- ☰ 7.2. What Is REST?
- ☰ 7.3. Resources and Endpoints
- ☰ 7.4. RESTful URL Design
- ☰ 7.5. HTTP Methods in REST
- ☰ 7.6. GET Requests
- ☰ 7.7. POST Requests
- ☰ 7.8. PUT Requests
- ☰ 7.9. PATCH Requests
- ☰ 7.10. DELETE Requests
- ☰ 7.11. Request Validation
- ☰ 7.12. Response Models
- ☰ 7.13. HTTP Status Codes
- ☰ 7.14. Error Responses
- ☰ 7.15. Pagination
- ☰ 7.16. Filtering
- ☰ 7.17. Sorting
- ☰ 7.18. Searching
- ☰ 7.19. API Versioning
- ☰ 7.20. API Documentation
- ☰ 7.21. OpenAPI and Swagger
-
- ☰ 8. FastAPI
- ☰ 8.1. Introduction to FastAPI
- ☰ 8.2. Routes and Path Operations
- ☰ 8.3. Path Parameters
- ☰ 8.4. Pydantic Models
- ☰ 8.5. Data Validation
- ☰ 8.6. Dependency Injection
- ☰ 8.7. Exception Handling
- ☰ 8.8. Background Tasks
- ☰ 8.9. File Uploads
- ☰ 8.10. Async Endpoints
- ☰ 8.11. FastAPI Project Structure
- ☰ 8.12. Building a Complete REST API
-
- ☰ 9. Databases
- ☰ 9.1. Introduction to Databases
- ☰ 9.2. Relational vs NoSQL Databases
- ☰ 9.3. Tables, Rows, and Columns
- ☰ 9.4. Primary Keys
- ☰ 9.5. Foreign Keys
- ☰ 9.6. Relationships
- ☰ 9.7. One-to-One Relationships
- ☰ 9.8. One-to-Many Relationships
- ☰ 9.9. Many-to-Many Relationships
- ☰ 9.10. Database Schema Design
- ☰ 9.11. Normalization
- ☰ 9.12. Indexes
- ☰ 9.13. Transactions
- ☰ 9.14. ACID Properties
-
- ☰ 10. SQL
- ☰ 10.1. Introduction to SQL
- ☰ 10.2. CREATE
- ☰ 10.3. INSERT
- ☰ 10.4. SELECT
- ☰ 10.5. UPDATE
- ☰ 10.6. DELETE
- ☰ 10.7. WHERE
- ☰ 10.8. ORDER BY
- ☰ 10.9. GROUP BY
- ☰ 10.10. Aggregate Functions
- ☰ 10.11. JOINs
- ☰ 10.12. Subqueries
- ☰ 10.13. Constraints
- ☰ 10.14. Indexes
- ☰ 10.15. Transactions
- ☰ 10.16. Common Table Expressions
- ☰ 10.17. SQL Performance Basics
-
- ☰ 11. PostgreSQL
- ☰ 11.1. Introduction to PostgreSQL
- ☰ 11.2. Installing PostgreSQL
- ☰ 11.3. Creating Databases
- ☰ 11.4. Users and Roles
- ☰ 11.5. Permissions
- ☰ 11.6. PostgreSQL Data Types
- ☰ 11.7. Constraints
- ☰ 11.8. Indexes
- ☰ 11.9. Transactions
- ☰ 11.10. JSON Data
- ☰ 11.11. Backup and Restore
- ☰ 11.12. PostgreSQL Performance Basics
-
- ☰ 12. ORM and Database Integration
- ☰ 12.1. What Is an ORM?
- ☰ 12.2. SQLAlchemy
- ☰ 12.3. Models
- ☰ 12.4. Database Sessions
- ☰ 12.5. Creating Records
- ☰ 12.6. Reading Records
- ☰ 12.7. Updating Records
- ☰ 12.8. Deleting Records
- ☰ 12.9. Relationships
- ☰ 12.10. Queries
- ☰ 12.11. Transactions
- ☰ 12.12. Connection Pooling
- ☰ 12.13. Database Migrations
- ☰ 12.14. Alembic
- ☰ 12.15. Repository Pattern
-
- ☰ 13. Authentication
- ☰ 13.1. Authentication vs Authorization
- ☰ 13.2. Password Storage
- ☰ 13.3. Password Hashing
- ☰ 13.4. Registration
- ☰ 13.5. Login
- ☰ 13.6. Tokens
- ☰ 13.7. JSON Web Tokens
- ☰ 13.8. Access Tokens
- ☰ 13.9. Refresh Tokens
- ☰ 13.10. OAuth 2.0
- ☰ 13.11. OpenID Connect
- ☰ 13.12. Social Login
- ☰ 13.13. Logout
- ☰ 13.14. Password Reset
- ☰ 13.15. Email Verification
- ☰ 13.16. Multi-Factor Authentication
-
- ☰ 14. Authorization
- ☰ 14.1. Users and Permissions
- ☰ 14.2. Role-Based Access Control
- ☰ 14.3. Permission-Based Access Control
- ☰ 14.4. Protecting API Endpoints
- ☰ 14.5. Admin Permissions
- ☰ 14.6. Resource Ownership
- ☰ 14.7. Authorization Best Practices
-
- ☰ 15. Backend Security
- ☰ 15.1. Introduction to Web Security
- ☰ 15.2. HTTPS and TLS
- ☰ 15.3. SQL Injection
- ☰ 15.4. Cross-Site Scripting
- ☰ 15.5. Cross-Site Request Forgery
- ☰ 15.6. CORS
- ☰ 15.7. Authentication Attacks
- ☰ 15.8. Brute-Force Protection
- ☰ 15.9. Rate Limiting
- ☰ 15.10. Input Validation
- ☰ 15.11. Secure Password Storage
- ☰ 15.12. Secrets Management
- ☰ 15.13. Secure Cookies
- ☰ 15.14. Security Headers
- ☰ 15.15. File Upload Security
- ☰ 15.16. Dependency Vulnerabilities
- ☰ 15.17. OWASP Top 10
-
- ☰ 16. Caching
- ☰ 16.1. Why Caching Matters
- ☰ 16.2. Application Caching
- ☰ 16.3. Redis
- ☰ 16.3.1. Introduction to Redis
- ☰ 16.3.2. Installing Redis
- ☰ 16.3.3. Keys and Values
- ☰ 16.3.4. Expiration
- ☰ 16.3.5. Distributed Locks
-
- ☰ 16.4. Cache Keys
- ☰ 16.5. Cache Invalidation
- ☰ 16.6. Caching Database Queries
- ☰ 16.7. Distributed Caching
-
- ☰ 17. Background Processing
- ☰ 17.1. Synchronous vs Asynchronous Tasks
- ☰ 17.2. Background Jobs
- ☰ 17.3. Message Queues
- ☰ 17.4. Celery
- ☰ 17.5. Redis as a Message Broker
- ☰ 17.6. Scheduled Tasks
- ☰ 17.7. Retry Strategies
- ☰ 17.8. Handling Failed Jobs
- ☰ 17.9. Email Jobs
- ☰ 17.10. Long-Running Tasks
-
- ☰ 18. Email
- ☰ 18.1. How Email Works
- ☰ 18.2. SMTP
- ☰ 18.3. Sending Emails
- ☰ 18.4. HTML Emails
- ☰ 18.5. Transactional Emails
- ☰ 18.6. Password Reset Emails
- ☰ 18.7. Background Email Delivery
- ☰ 18.8. Email Delivery Best Practices
-
- ☰ 19. Testing
- ☰ 19.1. Why Backend Testing Matters
- ☰ 19.2. Unit Testing
- ☰ 19.3. Integration Testing
- ☰ 19.4. API Testing
- ☰ 19.5. pytest
- ☰ 19.6. Fixtures
- ☰ 19.7. Mocking
- ☰ 19.8. Testing Databases
- ☰ 19.9. Testing Authentication
- ☰ 19.10. Testing FastAPI
- ☰ 19.11. Test Coverage
- ☰ 19.12. Automated Testing
-
- ☰ 20. Logging and Monitoring
- ☰ 20.1. Application Logging
- ☰ 20.2. Log Levels
- ☰ 20.3. Structured Logging
- ☰ 20.4. Request Logging
- ☰ 20.5. Error Logging
- ☰ 20.6. Metrics
- ☰ 20.7. Health Checks
- ☰ 20.8. Monitoring
- ☰ 20.9. Prometheus
- ☰ 20.10. Grafana
- ☰ 20.11. Alerting
- ☰ 20.12. Error Tracking
- ☰ 20.13. Observability Basics
-
- ☰ 21. Docker
- ☰ 21.1. Introduction to Containers
- ☰ 21.2. Docker Architecture
- ☰ 21.3. Images
- ☰ 21.4. Containers
- ☰ 21.5. Dockerfiles
- ☰ 21.6. Building Images
- ☰ 21.7. Running Containers
- ☰ 21.8. Volumes
- ☰ 21.9. Networks
- ☰ 21.10. Docker Compose
- ☰ 21.11. FastAPI with Docker
- ☰ 21.12. PostgreSQL with Docker
- ☰ 21.13. Redis with Docker
- ☰ 21.14. Multi-Container Applications
- ☰ 21.15. Production Docker Best Practices
-
- ☰ 22. Web Servers and Reverse Proxies
- ☰ 22.1. Application Servers
- ☰ 22.2. Uvicorn
- ☰ 22.3. Gunicorn
- ☰ 22.4. Reverse Proxies
- ☰ 22.5. Nginx
- ☰ 22.6. Traefik
- ☰ 22.7. HTTPS
- ☰ 22.8. TLS Certificates
- ☰ 22.9. Let's Encrypt
- ☰ 22.10. Load Balancing
-
- ☰ 23. Deployment
- ☰ 23.1. Development vs Production
- ☰ 23.2. Preparing an Application for Production
- ☰ 23.3. Linux Server Setup
- ☰ 23.4. Deploying with Docker
- ☰ 23.5. Environment Configuration
- ☰ 23.6. Managing Secrets
- ☰ 23.7. HTTPS Configuration
- ☰ 23.8. Production Logging
- ☰ 23.9. Backups
- ☰ 23.10. Zero-Downtime Deployment
- ☰ 23.11. Rollbacks
-
- ☰ 24. CI/CD
- ☰ 24.1. Introduction to CI/CD
- ☰ 24.2. Continuous Integration
- ☰ 24.3. Continuous Delivery
- ☰ 24.4. Continuous Deployment
- ☰ 24.5. CI/CD Pipelines
- ☰ 24.6. GitHub Actions
- ☰ 24.7. GitLab CI/CD
- ☰ 24.8. Building Docker Images
- ☰ 24.9. Container Registries
- ☰ 24.10. Deployment Pipelines
- ☰ 24.11. Staging Environments
- ☰ 24.12. Production Environments
- ☰ 24.13. Rollback Strategies
-
- ☰ 25. Backend Architecture
- ☰ 25.1. Monolithic Architecture
- ☰ 25.2. Modular Monoliths
- ☰ 25.3. Microservices
- ☰ 25.4. Layered Architecture
- ☰ 25.5. Service Layer
- ☰ 25.6. Separation of Concerns
- ☰ 25.7. Domain-Driven Design Basics
- ☰ 25.8. Event-Driven Architecture
- ☰ 25.9. Choosing an Architecture
-
- ☰ 26. Performance and Scalability
- ☰ 26.1. Understanding Backend Performance
- ☰ 26.2. CPU-Bound vs I/O-Bound Work
- ☰ 26.3. Asynchronous Programming
- ☰ 26.4. Database Optimization
- ☰ 26.5. Query Optimization
- ☰ 26.6. Indexing
- ☰ 26.7. Load Balancing
- ☰ 26.8. Horizontal Scaling
- ☰ 26.9. Vertical Scaling
- ☰ 26.10. Stateless Applications
- ☰ 26.11. Performance Testing
- ☰ 26.12. Load Testing
-
- ☰ 27. Advanced API Development
- ☰ 27.1. WebSockets
- ☰ 27.2. Server-Sent Events
- ☰ 27.3. GraphQL
- ☰ 27.4. Webhooks
- ☰ 27.5. Idempotency
- ☰ 27.6. API Rate Limiting
- ☰ 27.7. API Keys
- ☰ 27.8. API Gateways
- ☰ 27.9. Distributed APIs
- ☰ 27.10. Real-Time Applications
-
- ☰ 28. Production Backend Engineering
- ☰ 28.1. Configuration Management
- ☰ 28.2. Database Backups
- ☰ 28.3. Disaster Recovery
- ☰ 28.4. Graceful Shutdown
- ☰ 28.5. Fault Tolerance
- ☰ 28.6. Circuit Breakers
- ☰ 28.7. High Availability
- ☰ 28.8. Monitoring Production Systems
- ☰ 28.9. Incident Response
-
- ☰ 29. Project 1: Task Management API
- ☰ 29.1. Project Requirements
- ☰ 29.2. Project Structure
- ☰ 29.3. Database Design
- ☰ 29.4. CRUD Operations
- ☰ 29.5. Validation
-
- ☰ 30. Project 2: Authentication System
- ☰ 30.1. User Registration
- ☰ 30.2. JWT Authentication
- ☰ 30.3. Role-Based Authorization
- ☰ 30.4. Security Testing
-
- ☰ 31. Project 3: E-Commerce Backend
- ☰ 31.1. Architecture
- ☰ 31.2. User Management
- ☰ 31.3. Product Management
- ☰ 31.4. Categories
- ☰ 31.5. Shopping Cart
- ☰ 31.6. Orders
- ☰ 31.7. Inventory
- ☰ 31.8. Payments
- ☰ 31.9. Admin API
-
- ☰ 32. Final Project: Production Backend
- ☰ 32.1. Planning the Application
- ☰ 32.2. Designing the Architecture
- ☰ 32.3. Designing the Database
- ☰ 32.4. Building the REST API
- ☰ 32.5. Authentication and Authorization
- ☰ 32.6. PostgreSQL Integration
- ☰ 32.7. Redis Integration
- ☰ 32.8. Background Workers
- ☰ 32.9. File Storage
- ☰ 32.10. Dockerizing the Application
- ☰ 32.11. CI/CD Pipeline
- ☰ 32.12. Production Deployment
- ☰ 32.13. HTTPS and Domain Setup
- ☰ 32.14. Performance Optimization
- ☰ 32.15. Security Review
- ☰ 32.16. Documentation
-
- ☰ 33. Backend Developer Roadmap
- ☰ 33.1. What You Should Know Now
- ☰ 33.2. Building a Portfolio
- ☰ 33.3. Creating Backend Projects
- ☰ 33.4. Contributing to Open Source
- ☰ 33.5. Preparing for Backend Interviews
- ☰ 33.6. Backend Interview Questions
- ☰ 33.7. Database Interview Questions
- ☰ 33.8. API Interview Questions
- ☰ 33.9. Linux and Docker Interview Questions
- ☰ 33.10. Where to Go Next
-
Comments
Please login to add a comment.
Don't have an account? Register now!