12.5. Creating Records
Table of Contents
Why Creating Records Matters
In almost every backend application you will need to store new data in a database. When a user signs up, creates a blog post, adds a product to a catalog, or submits a form, the backend has to:
- Receive data from the client.
- Validate and transform it.
- Insert it into the database.
- Return a meaningful response.
In this chapter you will see how to do step 3 with an ORM, focusing on SQLAlchemy style patterns, which are common in Python backends. You will learn how to:
- Turn input data into ORM model instances.
- Add them to the database session.
- Commit them safely.
- Handle common pitfalls like missing fields or duplicate data.
We will assume you already know what an ORM is and what a database session is, and that you have models defined. Here we focus only on creating records.
Basic Pattern for Creating a Record
When you use an ORM, creating a record usually follows this pattern:
- Create a model instance with the desired values.
- Add it to the database session.
- Commit the session.
- (Optionally) refresh and return the created object.
In SQLAlchemy style code, this often looks like:
new_user = User(
email="alice@example.com",
name="Alice",
)
session.add(new_user)
session.commit()
session.refresh(new_user)
After commit(), the object now exists in the database. After refresh(), any fields that the database generated automatically, such as an id, are available on the instance.
Core pattern for creating records with an ORM
- Instantiate the model:
obj = Model(**data) - Add to the session:
session.add(obj) - Commit the transaction:
session.commit() - Refresh if you need updated fields:
session.refresh(obj)
Creating a Simple Record
Let us start with a very simple example. Suppose you have a User model:
from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import declarative_base
Base = declarative_base()
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True, index=True)
email = Column(String, unique=True, index=True, nullable=False)
name = Column(String, nullable=False)
You have a session object, typically from SessionLocal() or similar.
Inserting a Single Record
def create_user(session, email: str, name: str) -> User:
user = User(email=email, name=name) # 1. create instance
session.add(user) # 2. stage for insert
session.commit() # 3. write to DB
session.refresh(user) # 4. load generated fields
return userWhat happens here:
- Before
commit,userhas noid, because the database has not inserted it yet. - After
commit, the insert is done. session.refresh(user)asks the database for the current data of that row, souser.idgets populated.
If you print before and after:
user = User(email="bob@example.com", name="Bob")
print("Before commit:", user.id) # Usually None
session.add(user)
session.commit()
session.refresh(user)
print("After commit:", user.id) # Now has an integerWorking with Default Values and Auto-Generated Fields
Many columns have default values, or values that the database generates automatically:
- Auto-incrementing
id. - Timestamps such as
created_atorupdated_at. - Status fields with a default value.
- UUIDs generated by the database.
You usually do not pass these fields when you construct the object. The ORM and database handle them.
Example: Model with Defaults
from sqlalchemy import Column, Integer, String, DateTime, func, Boolean
class Post(Base):
__tablename__ = "posts"
id = Column(Integer, primary_key=True)
title = Column(String, nullable=False)
published = Column(Boolean, nullable=False, default=False)
created_at = Column(DateTime, server_default=func.now(), nullable=False)Creating a Post Without Defaults
def create_post(session, title: str) -> Post:
post = Post(title=title) # Do not pass 'published' or 'created_at'
session.add(post)
session.commit()
session.refresh(post)
return postAfter commit:
post.publishedwill beFalse, from the default.post.created_atwill be set to the current time by the database.
If you check:
post = create_post(session, "My first post")
print(post.published) # False
print(post.created_at) # Datetime value from DBLet the database handle:
- Auto-increment primary keys.
created_atandupdated_attimestamps.- Boolean flags with defaults.
Do not manually set them unless you have a good reason.
Creating Multiple Records at Once
Sometimes you need to insert many rows, for example:
- Seeding initial data like roles or categories.
- Bulk import from a CSV file.
- Creating test data.
You can create multiple instances and add them in one batch.
Example: Inserting Several Users
def create_many_users(session, users_data: list[dict]) -> list[User]:
users = [User(**data) for data in users_data] # Create many objects
session.add_all(users) # Add all to session
session.commit() # One commit
for user in users:
session.refresh(user) # Refresh if needed
return usersUsage:
users_data = [
{"email": "a@example.com", "name": "User A"},
{"email": "b@example.com", "name": "User B"},
{"email": "c@example.com", "name": "User C"},
]
users = create_many_users(session, users_data)
for u in users:
print(u.id, u.email)Performance Note
add_allstill sends each row through the ORM.- For very large inserts, ORMs often provide bulk methods such as
session.bulk_save_objectsorsession.bulk_insert_mappings. These can be faster but skip some ORM features like events or identity tracking.
Example of a bulk insert with mappings:
def bulk_insert_users(session, users_data: list[dict]):
session.bulk_insert_mappings(User, users_data)
session.commit()Use bulk inserts mostly for imports or seeding, not for everyday API operations that need full ORM behavior.
Handling Relationships When Creating Records
Creating records often involves relationships between tables, such as:
- A user has many posts.
- An order has many order items.
- A comment belongs to a post.
You need to create records that correctly reference each other.
We will look at typical patterns with foreign keys and ORM relationships.
Creating a Child Record with a Foreign Key
Suppose you have:
from sqlalchemy import Column, Integer, String, ForeignKey
from sqlalchemy.orm import relationship
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True)
email = Column(String, unique=True, nullable=False)
posts = relationship("Post", back_populates="author")
class Post(Base):
__tablename__ = "posts"
id = Column(Integer, primary_key=True)
title = Column(String, nullable=False)
body = Column(String, nullable=False)
author_id = Column(Integer, ForeignKey("users.id"), nullable=False)
author = relationship("User", back_populates="posts")Option 1: Set the Foreign Key Field Directly
def create_post_for_user(session, user_id: int, title: str, body: str) -> Post:
post = Post(
title=title,
body=body,
author_id=user_id, # directly set FK
)
session.add(post)
session.commit()
session.refresh(post)
return post
This works if you already know user_id. It is simple and common in REST APIs, where the route might be /users/{user_id}/posts.
Option 2: Use the Relationship Attribute
You can also assign the parent object instead of the foreign key.
def create_post_for_user(session, user_email: str, title: str, body: str) -> Post:
user = session.query(User).filter_by(email=user_email).one()
post = Post(
title=title,
body=body,
author=user, # assign relationship
)
session.add(post)
session.commit()
session.refresh(post)
return post
Here the ORM automatically sets author_id to user.id.
Creating Parent and Child Records Together
You can create a parent and its children in one go. The ORM will take care of inserting them in the correct order.
def create_user_with_posts(session, email: str, posts_data: list[dict]) -> User:
user = User(
email=email,
posts=[Post(**p) for p in posts_data] # create children via relationship
)
session.add(user)
session.commit()
session.refresh(user)
return userUsage:
user = create_user_with_posts(
session,
"carol@example.com",
posts_data=[
{"title": "First post", "body": "Hello"},
{"title": "Second post", "body": "More text"},
],
)
print(user.id)
print(len(user.posts)) # 2
print(user.posts[0].author_id) # same as user.idThe ORM:
- Inserts the
usersrow. - Gets the
idof the new user. - Inserts rows in
postswithauthor_idequal to thatid.
When creating related records:
- You can set foreign key fields directly, for example
author_id. - Or you can set relationship attributes, for example
authororposts. - The ORM will handle insert order and foreign key values for related objects in the same session.
Avoiding Common Pitfalls
Creating records is easy, but several mistakes appear often in real projects. Here are typical problems and how to avoid them.
Forgetting to Commit
If you add an object but forget session.commit(), nothing reaches the database.
Bad:
user = User(email="x@example.com", name="X")
session.add(user)
# missing session.commit()If the session is closed or rolled back, the new user disappears.
Better:
user = User(email="x@example.com", name="X")
session.add(user)
session.commit()
session.refresh(user)Forgetting to Add Before Commit
Another common error is to call commit without adding anything.
Bad:
user = User(email="x@example.com", name="X")
# forgot session.add(user)
session.commit()
Result: the user is never inserted. Always ensure you call add or add_all (or another method that registers the object) before commit.
Not Handling Constraint Errors
If your table has constraints, for example:
emailisUNIQUE.- Some columns are
NOT NULL.
The database will reject invalid inserts.
Example of a unique constraint:
email = Column(String, unique=True, nullable=False)Trying to insert two users with the same email:
user1 = User(email="dup@example.com", name="One")
user2 = User(email="dup@example.com", name="Two")
session.add_all([user1, user2])
session.commit() # will raise an IntegrityErrorYou should catch this kind of error and respond appropriately in your application.
Example handle:
from sqlalchemy.exc import IntegrityError
def safe_create_user(session, email: str, name: str) -> User | None:
user = User(email=email, name=name)
session.add(user)
try:
session.commit()
except IntegrityError:
session.rollback()
return None
session.refresh(user)
return userNow callers can see that a duplicate was not created.
Mixing Session Lifetimes and Objects
You should not:
- Use objects created in one session with another session.
- Keep ORM instances around for a very long time while sessions are closed.
Bad:
user = create_user(session1, "a@example.com", "A")
session1.close()
# Later, in another part of the code:
session2.add(user) # can cause errors or warningsBetter:
- Return plain data (for example Pydantic models or dictionaries) from functions.
- Use a short-lived session per request in web applications, and not keep ORM instances past that request.
Patterns for Create Functions in a Backend
In a real backend, you usually wrap creation logic in functions or classes. Here is a simple pattern that fits many codebases.
Example: Repository-Style Create
class UserRepository:
def __init__(self, session):
self.session = session
def create(self, email: str, name: str) -> User:
user = User(email=email, name=name)
self.session.add(user)
self.session.commit()
self.session.refresh(user)
return userUsage in a route handler (pseudocode):
def create_user_endpoint(request_body, session):
repo = UserRepository(session)
user = repo.create(
email=request_body.email,
name=request_body.name,
)
return {
"id": user.id,
"email": user.email,
"name": user.name,
}You can extend this pattern with:
- Input models for validation.
- Error handling for duplicates.
- Logging or events.
Summary
You have seen how to:
- Create a new ORM instance and add it to the session.
- Commit and refresh to get auto-generated fields like primary keys.
- Use default and auto-generated values without manually setting them.
- Insert multiple records with
add_allor bulk methods. - Create records that belong to other records through relationships.
- Avoid common mistakes such as missing
commitor ignoring constraint errors. - Wrap creation logic in functions or repository classes.
These patterns are the foundation for building endpoints like "create user", "create post", "create order", and any other "create" operation in your backend.
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!