10.1. Introduction to SQL
Table of Contents
Why SQL Matters for Backend Developers
When you build backend applications, you almost always need to store and retrieve data. User accounts, orders, blog posts, comments, logs, payments, all of these live in a database.
Relational databases such as PostgreSQL, MySQL, and SQLite dominate backend systems. They all speak a common language called SQL, which stands for Structured Query Language.
SQL is the standard way to:
- Define what data you want to store.
- Insert new data.
- Read data.
- Update existing data.
- Delete data.
If you work as a backend developer, you will use SQL regularly, even if you use an ORM in your code.
Key idea: SQL is the standard language used to communicate with relational databases.
If you know SQL, you can work with any relational database.
This chapter gives you a gentle introduction to what SQL is and how you will use it, without going deep into each command, because those will have their own dedicated chapters.
What SQL Is (and Is Not)
SQL as a Query Language
SQL is a declarative language. That means you describe what you want, not how to get it.
Example in plain English:
"Give me all users who registered today."
Example in SQL:
SELECT *
FROM users
WHERE registration_date = CURRENT_DATE;You do not say:
- How to look through the
userstable. - Which algorithm to use.
- How to optimize the lookup.
The database engine decides all of that.
SQL Is Not a General Programming Language
SQL is powerful, but it is not meant to replace your backend language such as Python or JavaScript.
You cannot use SQL alone to:
- Build a web server.
- Handle HTTP requests.
- Send emails.
- Render HTML pages.
Instead, you use SQL from inside your backend application to talk to the database.
A typical backend stack looks like this:
| Layer | Role | Example |
|---|---|---|
| HTTP framework | Handles requests and responses | FastAPI, Django, Express, Laravel |
| Application code | Business logic | Python, JavaScript, Java, Go |
| Database | Stores data | PostgreSQL, MySQL, SQLite |
| SQL | Language to talk to the database | SELECT, INSERT, UPDATE, DELETE |
The Two Main Uses of SQL
Everyday SQL usage falls into two large categories.
1. Data Definition: Creating and Changing Structure (DDL)
You use SQL to define what tables exist and what columns they have. This is called Data Definition Language (DDL).
Typical DDL commands:
CREATE: create databases, tables, indexes.ALTER: change existing tables or columns.DROP: delete tables or other objects.
Example: defining a simple users table:
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email VARCHAR(255) NOT NULL UNIQUE,
name VARCHAR(100) NOT NULL,
created_at TIMESTAMP NOT NULL DEFAULT NOW()
);
You will learn details of CREATE later in the chapter called CREATE.
2. Data Manipulation: Working with the Rows (DML)
You use SQL to work with the data stored inside tables. This is called Data Manipulation Language (DML).
Typical DML commands:
INSERT: add new rows.SELECT: read rows.UPDATE: modify existing rows.DELETE: remove rows.
Example: adding a new user:
INSERT INTO users (email, name)
VALUES ('alice@example.com', 'Alice');Example: reading all users:
SELECT id, email, name
FROM users;You will study each of these commands in its own chapter in this SQL section.
Basic SQL Concepts: Databases, Tables, and Rows
Databases and Schemas
In relational systems, you organize data like this:
- Database: a container of all data for an application or group of applications.
- Schema: an optional sub-division inside a database, which contains tables and other objects.
- Table: a collection of related data items, structured in rows and columns.
In PostgreSQL, for example:
- You might have a database named
shop. - Inside
shop, a schema namedpublic. - Inside
public, tables likeusers,products,orders.
Backends usually connect to a single database and operate inside one or more schemas.
Tables: Like Spreadsheets in the Database
A table is similar to a spreadsheet:
- Columns define the fields (for example
id,email,price). - Rows define individual records (for example one user or one order).
Example users table:
| id | name | created_at | |
|---|---|---|---|
| 1 | alice@example.com | Alice | 2024-04-01 10:05:00 |
| 2 | bob@example.com | Bob | 2024-04-01 11:10:00 |
SQL uses data types for columns, for example:
INTEGERfor whole numbers.VARCHAR(255)for short text.TEXTfor long text.BOOLEANfor true or false.TIMESTAMPfor date and time.
Data types affect what you can store and how the database optimizes it, but their details are covered under database specific chapters.
Rows and Columns: Terminology
You will often hear:
- Row: a single record in a table.
- Column: a named field of each record.
In SQL syntax, you will see:
INSERToperates on rows.SELECTpicks columns to show.UPDATEchanges column values in some rows.DELETEremoves rows.
Simple examples, using the users table:
-- choose specific columns
SELECT id, email
FROM users;
-- update a column in one row
UPDATE users
SET name = 'Alice Wonderland'
WHERE id = 1;
-- delete one row
DELETE FROM users
WHERE email = 'bob@example.com';Common SQL Statement Structure
Most SQL commands follow a predictable pattern.
Basic `SELECT` Structure
The most important command is SELECT, which reads data.
General shape:
SELECT column1, column2, ...
FROM table_name
WHERE some_condition
ORDER BY some_column;Example:
SELECT id, email
FROM users
WHERE created_at >= '2024-01-01'
ORDER BY created_at DESC;Meaning:
SELECT id, emailtells the database which columns we want to see.FROM userstells it which table to read from.WHERE created_at >= '2024-01-01'filters rows.ORDER BY created_at DESCsorts the result.
Later chapters like SELECT, WHERE, and ORDER BY will explain each part in detail.
SQL Keywords and Case Sensitivity
Typical style rules:
- SQL keywords are often written in uppercase, for example
SELECT,FROM,WHERE,INSERT. - Table and column names are often in lowercase with underscores, for example
users,created_at.
Most relational databases:
- Treat keywords case-insensitively, so
select,Select, andSELECTare all valid. - Handle identifiers like table names in a more complex way, which you will see in database specific chapters.
For this course, you can safely:
- Write SQL keywords in uppercase.
- Write table and column names in lowercase.
Running SQL: Where and How
Interactive SQL Consoles
Most databases provide a command line client where you can type SQL manually.
Examples:
- PostgreSQL:
psql - MySQL/MariaDB:
mysql - SQLite:
sqlite3
Example session in PostgreSQL:
-- create a table
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email VARCHAR(255) NOT NULL
);
-- insert a row
INSERT INTO users (email)
VALUES ('alice@example.com');
-- read the table
SELECT * FROM users;You will see the result printed in your terminal.
GUI Tools
You can also use a graphical tool:
- pgAdmin, DBeaver, TablePlus, DataGrip.
They usually have:
- A list of databases and tables on the side.
- A query editor window where you write SQL.
- A results area where query outcomes appear as tables.
From Your Backend Code
In real applications, SQL is usually executed from your backend code, not by you typing it manually.
For example, in Python with a library:
cursor.execute(
"SELECT id, email FROM users WHERE id = %s",
(user_id,)
)
row = cursor.fetchone()Your Python code prepares and sends SQL to the database, then reads the result. This integration is covered in later chapters on ORMs and database integration.
Basic Read and Write Examples
This section previews the core SQL operations you will learn in detail later.
Creating a Simple Table
CREATE TABLE products (
id SERIAL PRIMARY KEY,
name VARCHAR(100) NOT NULL,
price_cents INTEGER NOT NULL,
in_stock BOOLEAN NOT NULL DEFAULT TRUE
);What this does:
- Creates a
productstable. idis an auto increasing primary key.nameis required.price_centsstores the price in cents as an integer.in_stockis a boolean that defaults toTRUE.
Inserting Data
INSERT INTO products (name, price_cents, in_stock)
VALUES ('Coffee Mug', 1299, TRUE);Insert multiple rows in one statement:
INSERT INTO products (name, price_cents, in_stock)
VALUES
('T-Shirt', 1999, TRUE),
('Sticker Pack', 499, TRUE),
('Hoodie', 3999, FALSE);
You will later see the INSERT chapter where this is covered in depth.
Reading Data with `SELECT`
Get all products:
SELECT * FROM products;Get only names and prices:
SELECT name, price_cents
FROM products;Filter products that are in stock:
SELECT name, price_cents
FROM products
WHERE in_stock = TRUE;Sort by price, highest first:
SELECT name, price_cents
FROM products
ORDER BY price_cents DESC;The chapters SELECT, WHERE, and ORDER BY will show many more patterns like this.
Updating Data
Mark a product as out of stock:
UPDATE products
SET in_stock = FALSE
WHERE name = 'Coffee Mug';Increase all prices by 10 percent:
UPDATE products
SET price_cents = price_cents * 1.10;
The UPDATE chapter will explore safe patterns to avoid changing the wrong rows.
Deleting Data
Remove a product:
DELETE FROM products
WHERE name = 'Sticker Pack';Remove all products that are out of stock:
DELETE FROM products
WHERE in_stock = FALSE;
The DELETE chapter will show how to use WHERE carefully to avoid deleting too much.
SQL and Relational Thinking
Relationships between Tables
Relational databases are built around the idea of relationships between tables.
Example tables:
usersorders
A basic orders table might look like:
CREATE TABLE orders (
id SERIAL PRIMARY KEY,
user_id INTEGER NOT NULL,
total_cents INTEGER NOT NULL,
created_at TIMESTAMP NOT NULL DEFAULT NOW()
);Here:
user_idrefers to theidof a user in theuserstable.- This creates a relationship: each order belongs to one user.
Later chapters on JOINs, Foreign Keys, and Relationships will show how to:
- Enforce these links.
- Query across tables.
Joining Data from Multiple Tables
One of SQLs most powerful features is the JOIN.
Example: you want to see orders with user emails:
SELECT
orders.id,
users.email,
orders.total_cents
FROM orders
JOIN users ON orders.user_id = users.id;This gives you a combined view of two tables. The JOINs chapter explains different join types and use cases in detail.
SQL Grammar: Statements, Clauses, and Expressions
To read SQL documentation and error messages, it helps to know the basic grammar words.
Statements
A statement is one complete command. For example:
SELECT * FROM users;
Each statement usually ends with a semicolon ;.
Other examples of statements:
CREATE TABLE ...;INSERT INTO ...;UPDATE ...;DELETE FROM ...;
Clauses
A statement is built from one or more clauses. In a SELECT statement, common clauses are:
SELECTclauseFROMclauseWHEREclauseORDER BYclauseGROUP BYclause
Example:
SELECT email, COUNT(*) AS order_count -- SELECT clause
FROM orders -- FROM clause
JOIN users ON orders.user_id = users.id -- JOIN clause
WHERE orders.created_at >= '2024-01-01' -- WHERE clause
GROUP BY email -- GROUP BY clause
ORDER BY order_count DESC; -- ORDER BY clauseEach clause has a specific role, which you will see in the dedicated chapters.
Expressions
Within clauses, you use expressions. These can be:
- Column names:
price_cents - Literals:
100,'Alice' - Function calls:
COUNT(*),NOW() - Arithmetic:
price_cents * 1.10 - Comparisons:
price_cents > 1000
Example:
SELECT name, price_cents * 1.15 AS price_with_tax
FROM products
WHERE price_cents > 1000;
Here, price_cents * 1.15 is an expression.
SQL and Standards: Differences Between Databases
SQL is standardized, but each database has its own dialect and features.
Common points:
- Core commands like
SELECT,INSERT,UPDATE,DELETE,CREATE TABLE,DROP TABLEwork similarly. - Most basic filters and sorting work the same.
Differences can include:
- Exact data types and type names.
- Functions and their names.
- Some syntax details.
- Extra features, for example JSON support.
In this course:
- The general SQL chapter (this one and the following SQL basics) focuses on concepts that apply to all relational databases.
- Database specific chapters like PostgreSQL show details and differences for a specific engine.
How SQL Fits into Backend Development
Typical Backend Workflow with SQL
A backend that uses SQL usually does the following:
- Define the schema with
CREATE TABLEand other DDL statements. - Insert initial data, for example an admin user or configuration.
- In response to API calls:
- Use
SELECTto read from tables. - Use
INSERTwhen creating new items. - Use
UPDATEwhen modifying existing items. - Use
DELETEfor removal. - Over time:
- Evolve the schema using
ALTER TABLE. - Migrate data when requirements change.
All of these operations are usually wrapped in transactions, which you will study in the Transactions chapter.
ORMs and SQL
Many backends use an ORM so you write code like:
user = User(email="alice@example.com")
session.add(user)
session.commit()Instead of writing raw SQL by hand.
However, the ORM translates that down to SQL such as:
INSERT INTO users (email)
VALUES ('alice@example.com');To use an ORM effectively, you must understand SQL concepts:
- Tables and columns.
- Primary keys and foreign keys.
- Joins and filters.
- Transactions and constraints.
Summary and What Comes Next
In this introduction you learned that:
- SQL is the standard language to work with relational databases.
- It is declarative: you describe what you want, not how to compute it.
- You use SQL both to define data structures and to manipulate data.
- Basic operations include:
CREATEtables.INSERTrows.SELECTto read.UPDATEto change.DELETEto remove.- SQL works with databases, tables, rows, and columns, with clear relationships between tables.
Core mental model:
- Store data in tables with columns and rows.
- Use SQL to define tables and insert / read / update / delete rows.
- Combine data from tables using joins.
In the next chapters, you will explore each main SQL operation in detail, starting with how to create tables and insert data, then how to query, filter, aggregate, and join data efficiently.
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!