10.3. INSERT
Table of Contents
Understanding INSERT in SQL
The INSERT statement adds new rows into a table. As a backend developer you will use it constantly when saving user data, orders, logs, and more.
This chapter focuses only on inserting data. Creating tables, updating, or selecting data are covered in other chapters.
Basic INSERT Syntax
The most common form of INSERT looks like this:
INSERT INTO table_name (column1, column2, column3)
VALUES (value1, value2, value3);Example:
INSERT INTO users (id, email, is_active)
VALUES (1, 'alice@example.com', true);
This inserts a single row into the users table.
Key points:
table_nameis the table where you add data.- Column list
(column1, column2, ...)defines which columns you are setting. VALUESprovides the actual data.- The number of columns must match the number of values and the order must match.
Rule: The number of columns in the column list must be equal to the number of values in the VALUES list, and each value must be type compatible with its column.
If the table is:
CREATE TABLE users (
id INT,
email VARCHAR(255),
is_active BOOLEAN
);Then this is valid:
INSERT INTO users (id, email, is_active)
VALUES (2, 'bob@example.com', false);But this is not:
-- Wrong: 3 columns, 2 values
INSERT INTO users (id, email, is_active)
VALUES (3, 'charlie@example.com');
-- Wrong: wrong type in is_active
INSERT INTO users (id, email, is_active)
VALUES (4, 'dan@example.com', 'yes');Your database will raise an error in such cases.
Inserting into All Columns
If you want to insert values for all columns in the table, and you know the exact column order, you can omit the column list:
INSERT INTO users
VALUES (5, 'eve@example.com', true);The values must match the order that the columns were defined in the table schema.
This can be dangerous if the table schema changes, so in real projects you usually specify column names explicitly.
Comparison:
| Style | Example | Pros | Cons |
|---|---|---|---|
| With column list | INSERT INTO users (id, email) VALUES (1, 'a@b.com'); | Clear, safe, order does not matter | Slightly more to type |
| Without column list | INSERT INTO users VALUES (1, 'a@b.com'); | Shorter | Breaks if table structure changes |
Best practice for backend code:
Always specify the columns you are inserting into. This makes the code clearer and more robust.
Inserting Multiple Rows at Once
You can insert several rows in one INSERT statement:
INSERT INTO users (id, email, is_active)
VALUES
(10, 'user1@example.com', true),
(11, 'user2@example.com', false),
(12, 'user3@example.com', true);This is often faster than multiple separate single-row inserts, and it reduces network round trips from your backend to the database.
Typical use cases:
- Seeding initial data (for example default roles).
- Importing a small batch of rows at once.
Using DEFAULT and NULL
Rows do not always need values for every column. Some columns may have:
- A default value defined in the table.
- Allow
NULL, which represents "no value".
Assume this table:
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email VARCHAR(255) NOT NULL,
is_active BOOLEAN NOT NULL DEFAULT true,
bio TEXT
);Omitting columns
If a column has a default or allows NULL, you can simply omit it from the insert:
INSERT INTO users (email)
VALUES ('no-bio@example.com');Result for that row:
idis auto generated.emailis'no-bio@example.com'.is_activeuses defaulttrue.bioisNULLbecause we did not set it and it has no default.
Using DEFAULT explicitly
You can also explicitly say "use the default here":
INSERT INTO users (email, is_active)
VALUES ('default-active@example.com', DEFAULT);This makes it very clear that you want the column to use its default.
Inserting NULL
If a column allows NULL, you can insert NULL explicitly:
INSERT INTO users (email, bio)
VALUES ('null-bio@example.com', NULL);Difference:
- Omitted column: database decides default or NULL according to table definition.
- Explicit
NULL: you are clearly saying "no value".
Inserting Specific Data Types
When inserting data you must respect column types.
Assume:
CREATE TABLE products (
id SERIAL PRIMARY KEY,
name VARCHAR(100) NOT NULL,
price NUMERIC(10, 2) NOT NULL,
in_stock BOOLEAN NOT NULL DEFAULT true,
created_at TIMESTAMP NOT NULL DEFAULT NOW()
);Strings (text)
- Wrap inside single quotes.
- Escape internal single quotes.
INSERT INTO products (name, price)
VALUES ('Basic T-Shirt', 9.99);
INSERT INTO products (name, price)
VALUES ('Men''s Jacket', 59.90); -- Note the doubled quoteNumbers
- Do not use quotes.
- Must be valid numeric values.
INSERT INTO products (name, price)
VALUES ('Coffee Mug', 4.50);Boolean
Most databases accept these:
true/false1/0(sometimes)'t'/'f'(PostgreSQL)
Recommended:
INSERT INTO products (name, price, in_stock)
VALUES ('Notebook', 2.00, true);Dates and timestamps
Use standard formats:
INSERT INTO products (name, price, created_at)
VALUES ('Limited Edition Poster', 15.00, '2024-01-15 10:30:00');
If the column has a default like NOW(), you can omit:
INSERT INTO products (name, price)
VALUES ('Sticker Pack', 3.00);INSERT with SELECT (Copying Data)
You can insert rows that come from another query, not from literal values.
Pattern:
INSERT INTO target_table (col1, col2, col3)
SELECT other_col1, other_col2, other_col3
FROM source_table
WHERE some_condition;
Example: Copy all active users into an active_users_archive table.
INSERT INTO active_users_archive (user_id, email, archived_at)
SELECT id, email, NOW()
FROM users
WHERE is_active = true;Here:
- The
SELECTproduces rows. - The
INSERTtakes those rows and adds them toactive_users_archive. - No
VALUESclause is used when you insert from aSELECT.
Use cases:
- Archiving data.
- Copying data between tables with similar structure.
- Creating backup snapshots of some rows.
The number and order of columns in the INSERT column list must match the number and order of expressions in the SELECT list.
Handling Auto-Increment / SERIAL Columns
Many tables have auto-generated primary keys, such as SERIAL in PostgreSQL, AUTO_INCREMENT in MySQL, or identity columns.
Example table:
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email VARCHAR(255) NOT NULL
);
You normally do not insert into the id column:
INSERT INTO users (email)
VALUES ('generated-id@example.com');
The database will choose the id for you.
If you try to insert your own id that conflicts with an existing one, you will get an error:
INSERT INTO users (id, email)
VALUES (1, 'duplicate-id@example.com'); -- Fails if id 1 existsIn backend code, the common pattern is:
- Do not set the auto-increment primary key in your insert.
- Let the database generate it.
- Retrieve the generated id if needed.
How to get the generated id depends on language and driver. For PostgreSQL you can also use:
INSERT INTO users (email)
VALUES ('returning-id@example.com')
RETURNING id;This returns the newly generated id as part of the query result.
INSERT and Constraints
Tables often have constraints such as:
PRIMARY KEYUNIQUENOT NULLFOREIGN KEY
When you insert rows, these constraints are checked.
Examples:
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email VARCHAR(255) NOT NULL UNIQUE
);
CREATE TABLE posts (
id SERIAL PRIMARY KEY,
user_id INT NOT NULL REFERENCES users(id),
title VARCHAR(255) NOT NULL
);PRIMARY KEY and UNIQUE
If a column is UNIQUE or a primary key, inserting a duplicate value causes an error:
INSERT INTO users (email)
VALUES ('unique@example.com');
INSERT INTO users (email)
VALUES ('unique@example.com'); -- Error: duplicate key valueNOT NULL
You cannot insert NULL or omit a required column without default:
INSERT INTO users (email)
VALUES (NULL); -- Error: email cannot be nullFOREIGN KEY
A foreign key must refer to an existing row in another table:
INSERT INTO posts (user_id, title)
VALUES (9999, 'Post by non-existent user'); -- ErrorUser with id 9999 does not exist, so the insert fails.
From a backend perspective this means:
- You often need to insert rows in the correct order, for example users before posts.
- You must handle errors when constraints are violated.
INSERT with RETURNING (Database Specific)
Some databases support RETURNING to return inserted rows. This is particularly useful in backend applications where you want to get the inserted row without doing a second query.
Example (PostgreSQL):
INSERT INTO users (email)
VALUES ('returning@example.com')
RETURNING id, email;The result might look like:
| id | |
|---|---|
| 42 | returning@example.com |
As a backend developer you can:
- Insert the row.
- Get the generated id and other fields immediately.
- Return them from your API response.
This is more efficient than:
- Insert the row.
- Do another
SELECTwith some unique key to fetch it.
Note: RETURNING is not part of standard SQL, but similar features exist in many databases, or in the database driver / ORM.
INSERT in Backend Code and Security
When you use INSERT from code, you must never build SQL strings by concatenating user input directly. That exposes you to SQL injection attacks.
Unsafe example (Python, do not do this):
email = input_email_from_user # Untrusted
sql = f"INSERT INTO users (email) VALUES ('{email}');"
cursor.execute(sql) # DangerousSafe example with parameterized query:
email = input_email_from_user # Untrusted
cursor.execute(
"INSERT INTO users (email) VALUES (%s);",
(email,)
)The database driver will safely escape the value.
Always use parameterized queries for INSERT statements that include user input. Never put raw user input into SQL strings.
In most backend frameworks and ORMs, parameterization is handled for you, but you should still understand why it matters.
Practical Examples
Example 1: Simple user registration
Table:
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email VARCHAR(255) NOT NULL UNIQUE,
password_hash TEXT NOT NULL,
created_at TIMESTAMP NOT NULL DEFAULT NOW()
);Insert when a new user registers:
INSERT INTO users (email, password_hash)
VALUES ('newuser@example.com', 'hashed_password_here');
With RETURNING to get id:
INSERT INTO users (email, password_hash)
VALUES ('newuser@example.com', 'hashed_password_here')
RETURNING id;Example 2: Seeding roles
CREATE TABLE roles (
id SERIAL PRIMARY KEY,
name VARCHAR(50) NOT NULL UNIQUE
);Insert multiple rows:
INSERT INTO roles (name)
VALUES
('admin'),
('editor'),
('viewer');Example 3: Copy active products to a sale table
CREATE TABLE products (
id SERIAL PRIMARY KEY,
name VARCHAR(100) NOT NULL,
price NUMERIC(10, 2) NOT NULL,
active BOOLEAN NOT NULL DEFAULT true
);
CREATE TABLE sale_products (
id SERIAL PRIMARY KEY,
original_id INT NOT NULL,
name VARCHAR(100) NOT NULL,
sale_price NUMERIC(10, 2) NOT NULL
);
Insert with SELECT:
INSERT INTO sale_products (original_id, name, sale_price)
SELECT id, name, price * 0.8
FROM products
WHERE active = true;
This copies all active products with a 20% discount into sale_products.
Summary
INSERTadds new rows to a table.- Use
INSERT INTO table_name (columns) VALUES (...);for single or multiple rows. - Omit columns that have defaults or allow
NULL, or useDEFAULTexplicitly. - Respect data types and constraints such as
NOT NULL,UNIQUE, andFOREIGN KEY. - Use
INSERT ... SELECT ...to copy data from one table to another. - For auto-increment keys, normally omit the id column and optionally use
RETURNINGwhere supported. - In backend code, always use parameterized queries to avoid SQL injection.
Understanding INSERT is a core skill. You will use it whenever your backend saves new data to the database.
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!