11.1. Introduction to PostgreSQL
Table of Contents
Why PostgreSQL Matters for Backend Development
PostgreSQL, often called “Postgres,” is a powerful open source relational database management system (RDBMS). As a backend developer, you will frequently need a reliable database to store and query application data. PostgreSQL is one of the most popular choices for modern web backends.
It is:
- Free and open source, with a large community
- Cross platform, runs on Linux, macOS, and Windows
- Very standards compliant, follows SQL standards closely
- Trusted in production by many companies for critical systems
PostgreSQL is not the only database you can use, but it is an excellent one to learn first because it gives you strong foundations for relational databases in general.
Key idea: PostgreSQL is a relational database that uses SQL to define, store, and query data in tables.
Learning PostgreSQL teaches you practical SQL plus concepts that apply to many other relational databases.
In this chapter, you will get an overview of what makes PostgreSQL special, what you can do with it, and how you will use it in backend projects. Installation, SQL, performance tuning, and so on will be handled in later chapters, so here we focus on the big picture.
PostgreSQL in the Database Landscape
There are many relational databases: MySQL, MariaDB, SQL Server, Oracle, SQLite, and others. PostgreSQL belongs to this family but has its own philosophy.
PostgreSQL vs other relational databases
Here is a rough comparison to build intuition.
| Database | License | Typical use cases | Strengths |
|---|---|---|---|
| PostgreSQL | Open source | Web apps, analytics, geospatial, microservices | Features, correctness, extensibility |
| MySQL | Open source | Web apps, LAMP stack, legacy apps | Simplicity, huge ecosystem |
| SQLite | Public domain | Mobile, embedded, small tools | Zero config, single file, very lightweight |
| Oracle | Commercial | Large enterprises, legacy systems | Enterprise tools, long history |
| SQL Server | Commercial/Free | Windows shops, .NET apps | Integration with Microsoft stack |
PostgreSQL focuses strongly on:
- Correctness and reliability
- Rich SQL features
- Extensibility (you can add data types, functions, and more)
This makes it a solid default for many backend applications, from small projects to large systems.
PostgreSQL vs NoSQL databases
You will also encounter NoSQL systems like MongoDB, Cassandra, and Redis. These are often:
- Document databases (for example MongoDB)
- Key value stores (for example Redis)
- Wide column stores (for example Cassandra)
- Graph databases
PostgreSQL is different because:
- It enforces schemas and constraints
- It uses SQL for queries
- It provides transactions with strong ACID guarantees
However, PostgreSQL has evolved and now includes features that feel “NoSQL like”, such as JSONB columns, key value style operations, and full text search. In many cases, you can keep using PostgreSQL instead of adding a second specialized database.
Core Concepts in PostgreSQL
Before using PostgreSQL in code, you need a conceptual map of its main building blocks.
Cluster, databases, schemas, and tables
PostgreSQL has a hierarchy of objects. This often confuses beginners, so keep this structure in mind:
| Level | Example name | Description |
|---|---|---|
| Cluster | One Postgres “server” process | Contains one or more databases |
| Database | my_app_db | Contains schemas, tables, functions, etc. |
| Schema | public | A namespace inside a database |
| Table | users | Stores rows of data with defined columns |
In practice for simple apps:
- You have one PostgreSQL server (cluster).
- Inside it, you create one database for your app.
- Inside that database, you use the default
publicschema. - Inside that schema, you create your tables (
users,orders,products, etc.).
Example mental model for a simple app:
- Cluster:
postgres@localhost - Database:
task_manager - Schema:
public - Table:
users - Table:
tasks
You will learn how to actually create these in later PostgreSQL chapters.
Data types and constraints
PostgreSQL has many data types, more than many other relational databases. Some common ones you will use often:
| Category | Examples |
|---|---|
| Numeric | INTEGER, BIGINT, NUMERIC, REAL |
| Text | TEXT, VARCHAR(n), CHAR(n) |
| Boolean | BOOLEAN |
| Date/Time | DATE, TIME, TIMESTAMP, TIMESTAMPTZ |
| Binary | BYTEA |
| JSON | JSON, JSONB |
| UUID | UUID |
You also use constraints to enforce rules:
NOT NULLvalue must be presentUNIQUEvalue must be unique in the tablePRIMARY KEYunique identifier for a rowFOREIGN KEYreference to another tableCHECKcustom conditions, for exampleage >= 0
These make your data safer and help prevent bugs in your backend code by catching invalid data early.
Example of a table definition (simplified, you will learn syntax later):
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email TEXT NOT NULL UNIQUE,
full_name TEXT NOT NULL,
is_active BOOLEAN NOT NULL DEFAULT TRUE
);Even if you do not know all the syntax yet, you can see:
idis the primary keyemailcannot be null and must be uniqueis_activehas a default valueTRUE
Typical PostgreSQL Use Cases in Backends
PostgreSQL supports many patterns you will see repeatedly when writing backend services.
Storing core application data
Most web apps need to store:
- Users
- Authentication data
- Domain objects, for example products, tasks, posts, orders
- Relations between these objects
PostgreSQL models this with tables and relationships.
Example: a task management app:
users
id (PK)
email
password_hash
tasks
id (PK)
user_id (FK to users.id)
title
description
is_completed
created_atYou can then answer questions such as:
- “Find all tasks for user with email
alice@example.com” - “Count completed tasks for each user”
All with SQL queries, which we cover in the SQL section of the course.
Transactions and consistency
In real applications, you frequently need several related changes to happen atomically. For example in an ecommerce app:
- Create an order
- Reduce product inventory
- Save a payment record
You want either all of these steps to succeed or none of them. PostgreSQL gives you:
- Transactions: groups of operations that are either fully committed or fully rolled back
- ACID guarantees: important properties that ensure reliability
You will have a separate chapter focused on transactions and ACID, but for now you should understand:
In PostgreSQL you can wrap multiple database operations in a transaction so they behave as a single, all-or-nothing unit of work.
This is essential for correct backend logic.
Advanced querying and analytics
PostgreSQL supports powerful SQL features such as:
- Joins to combine data from multiple tables
- Aggregations with
GROUP BYand functions likeCOUNT,SUM,AVG - Window functions for advanced calculations
- Common Table Expressions (CTEs) for readable complex queries
- Views to encapsulate frequently used queries
Even simple apps benefit from this. For example:
- “How many tasks did each user complete in the last 7 days?”
- “Show the 10 most recent orders with the total amount and user name.”
As you build more complex backends, these features become very valuable.
How Backend Code Talks to PostgreSQL
Your backend application does not talk SQL manually in a terminal in production. Instead, it connects to PostgreSQL over the network and runs queries through a driver or an ORM.
Client server model
PostgreSQL runs as a server process that listens on a port, typically 5432. Your backend application is a client:
- Your code opens a connection to PostgreSQL
- It sends SQL commands as text
- PostgreSQL executes them
- Results come back to your code
Example conceptual flow for a FastAPI endpoint:
- HTTP request:
GET /users/1 - FastAPI handler runs
- Handler uses SQLAlchemy (ORM)
- SQLAlchemy generates SQL like
SELECT * FROM users WHERE id = 1 - PostgreSQL executes the query and returns the row
- Handler serializes the result to JSON and returns an HTTP response
You will learn the details of ORMs and integration in later chapters, but this is the basic idea.
Connection parameters
To connect to PostgreSQL, you usually need:
| Parameter | Example |
|---|---|
| Host | localhost |
| Port | 5432 |
| Database | my_app_db |
| User | my_app_user |
| Password | secret_password |
These are often combined into a connection URL, for example:
postgresql://my_app_user:secret_password@localhost:5432/my_app_dbYour backend will use environment variables to store these values, for example:
DATABASE_URL=postgresql://my_app_user:secret_password@localhost:5432/my_app_db
Then your Python code reads DATABASE_URL and uses it to connect.
Strengths and Features that Matter to Backend Developers
PostgreSQL has many advanced features. You will not use all of them on day one, but it is useful to know what is available so you can pick the right tools later.
Rich data types for real world data
Some PostgreSQL data types are especially useful in backends:
- JSON and JSONB
- Store flexible JSON documents
- Query inside JSON fields, for example
preferences->>'theme' - Great for semi structured data like settings, logs, or integrations
- UUID
- Random unique identifiers like
550e8400-e29b-41d4-a716-446655440000 - Useful for public IDs in APIs, as they are hard to guess and do not expose table size
- Arrays
- Columns that hold arrays, for example
tags TEXT[] - Useful when you need a small list of values without a separate table
- Geospatial (PostGIS extension)
- Store locations, shapes, routes
- Important for maps, delivery apps, etc.
You will learn details of data types in the “PostgreSQL Data Types” chapter.
Indexes for performance
When tables grow large, queries can become slow. PostgreSQL uses indexes to speed up lookups, just like an index in a book.
Common example:
- Table
usershas 1 million rows - You often look up users by
email - You create an index on
email - PostgreSQL can now find a user by email much faster
We will cover indexes in both the SQL section and the PostgreSQL section, including how they work and when to use them.
Extensions and customization
PostgreSQL is very extensible. You can add:
- New data types
- New functions
- Procedural languages (PL/pgSQL, PL/Python, etc.)
- Full text search with advanced ranking
- Geospatial support via PostGIS
For most basic backends you will use the built in features only, but knowing that PostgreSQL can grow with your needs is important.
Example: Simple Application Data Model in PostgreSQL
To see PostgreSQL concepts in context, imagine a simple blog backend with:
- Users
- Posts
- Comments
A possible schema in PostgreSQL might look like this (simplified):
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email TEXT NOT NULL UNIQUE,
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE TABLE posts (
id SERIAL PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users(id),
title TEXT NOT NULL,
content TEXT NOT NULL,
published_at TIMESTAMPTZ,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE TABLE comments (
id SERIAL PRIMARY KEY,
post_id INTEGER NOT NULL REFERENCES posts(id),
user_id INTEGER NOT NULL REFERENCES users(id),
content TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);Concepts in this example:
- Each table has a primary key
id posts.user_idandcomments.user_idreferenceusers.idcomments.post_idreferencesposts.id- Timestamps use
TIMESTAMPTZ, a timezone aware type
From your backend code, you could:
- Insert a new user when someone registers
- Insert a post linked to that user
- Insert comments linked to both the post and the commenting user
- Query posts with their authors and comment counts
You will later represent these tables as Python classes when using an ORM like SQLAlchemy.
How You Will Use PostgreSQL in This Course
Throughout this course, PostgreSQL appears in several roles:
- Learning SQL
- You will run
CREATE,INSERT,SELECT,UPDATE, andDELETEstatements against PostgreSQL. - You will practice joins, aggregates, indexes, and transactions.
- Integrating with FastAPI
- You will connect FastAPI applications to PostgreSQL using SQLAlchemy.
- You will build REST APIs that read and write data in PostgreSQL.
- Using PostgreSQL in Docker
- You will run PostgreSQL in containers for local development.
- You will use
docker-composeto run FastAPI and PostgreSQL together. - Deploying to production
- You will configure PostgreSQL on a Linux server or use a managed PostgreSQL service.
- You will manage migrations, backups, and performance basics.
By the end of the PostgreSQL and ORM sections, you will be comfortable:
- Designing schemas for typical web applications
- Writing and optimizing common queries
- Integrating PostgreSQL into real backend services
Summary
In this chapter you learned the big picture of PostgreSQL:
- It is a powerful, open source relational database system, widely used in modern backends.
- It organizes data in databases, schemas, and tables, with rich data types and constraints.
- It supports transactions and ACID properties for reliable multi step operations.
- Backend applications talk to PostgreSQL over the network using drivers or ORMs.
- PostgreSQL offers advanced features like JSONB, indexes, full text search, and extensions.
Next, you will learn how to install PostgreSQL, connect to it, and start creating databases and tables that you can use from your backend code.
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!