5.11. Date and Time
Table of Contents
Working with Date and Time in Python
Date and time handling is a common backend task, for example when recording when a user registered, when an order was created, or when a token expires. Python provides powerful tools for this, but there are also many common mistakes.
This chapter focuses on how to use Python's date and time features correctly in backend applications, especially with time zones and serialization for APIs.
The `datetime` Module Overview
Python's built in datetime module is your main tool for working with dates and times.
It provides several key classes:
| Class | What it represents | Example use |
|---|---|---|
date | Calendar date only (year, month, day) | User's birthday |
time | Time of day only (hour, minute, second) | Daily notification time |
datetime | Date and time together | When an order was created |
timedelta | Duration or difference between two dates or times | Token lifetime, subscription period |
timezone | Fixed offset time zone | Represent UTC or a fixed offset zone |
Basic imports:
from datetime import date, time, datetime, timedelta, timezoneCreating Dates, Times, and Datetimes
Creating `date` objects
You usually create a date by specifying year, month, and day:
from datetime import date
d = date(2024, 5, 20) # year, month, day
print(d) # 2024-05-20
print(d.year, d.month, d.day) # 2024 5 20You can also get today's date:
today = date.today()
Backend example: store a user's birthday as a date, because the time of day is not important.
Creating `time` objects
A time holds only time of day, no date:
from datetime import time
t = time(14, 30, 15) # hour, minute, second
print(t) # 14:30:15
time is less commonly stored in backends than datetime, but it can be useful for things like "send a daily email at 09:00".
Creating `datetime` objects
datetime combines date and time:
from datetime import datetime
dt = datetime(2024, 5, 20, 14, 30, 15)
print(dt) # 2024-05-20 14:30:15Get the current local datetime (according to the server):
now_local = datetime.now()Get the current UTC datetime:
from datetime import timezone
now_utc = datetime.now(timezone.utc)
Backend example: store created_at and updated_at timestamps for database records as datetime values in UTC.
Naive vs Aware Datetimes and Time Zones
Time zones are a common source of bugs in backend systems, especially when servers, users, and databases are in different locations.
Naive vs aware
Python datetime objects are either:
- Naive: No time zone information
- Aware: Includes a time zone or offset from UTC
from datetime import datetime, timezone
naive = datetime.now() # naive, no tzinfo
aware = datetime.now(timezone.utc) # aware, tzinfo=UTC
print(naive.tzinfo) # None
print(aware.tzinfo) # UTC
Always store and process server-side datetimes in UTC using timezone aware datetime objects.
If you forget this rule, comparisons and calculations across time zones can become wrong, especially when daylight saving time changes.
Representing UTC correctly
To get a correct UTC timestamp:
from datetime import datetime, timezone
now_utc = datetime.now(timezone.utc)
Avoid using datetime.utcnow() in new code because it returns a naive datetime with no timezone, even though it represents UTC.
Converting between time zones
The standard library datetime.timezone only supports fixed offsets, not full region time zones like "Europe/Berlin". For those, use zoneinfo (Python 3.9+).
from datetime import datetime, timezone
from zoneinfo import ZoneInfo
utc_now = datetime.now(timezone.utc) # aware UTC datetime
# Convert to a user's local time zone
user_tz = ZoneInfo("Europe/Berlin")
user_time = utc_now.astimezone(user_tz)
print(utc_now) # 2024-05-20 13:00:00+00:00
print(user_time) # 2024-05-20 15:00:00+02:00 (example)Backend example: store login timestamps in UTC. When showing them in the UI, convert to the user's selected time zone.
Attaching a time zone
If you know a naive datetime is in UTC, you can "attach" UTC:
from datetime import datetime, timezone
naive_utc = datetime.utcnow() # naive, but logically UTC
aware_utc = naive_utc.replace(tzinfo=timezone.utc)
Be careful: replace(tzinfo=...) does not convert the time, it only attaches a time zone. Use astimezone when you want conversion.
Formatting and Parsing Dates and Times
Backend applications need to serialize datetimes to strings for JSON, logs, emails, and parse them back from incoming data.
ISO 8601 format
The most common format is ISO 8601. Python can produce and parse it easily.
from datetime import datetime, timezone
now = datetime(2024, 5, 20, 14, 30, 15, tzinfo=timezone.utc)
iso_str = now.isoformat()
print(iso_str) # 2024-05-20T14:30:15+00:00When building APIs, prefer ISO 8601 strings in UTC. Example JSON:
{
"id": 1,
"created_at": "2024-05-20T14:30:15Z",
"expires_at": "2024-05-21T14:30:15Z"
}
Z is a shorthand for +00:00 (UTC).
Custom formatting with `strftime`
Use strftime to format datetimes as strings using format codes.
Common codes:
| Code | Meaning | Example |
|---|---|---|
%Y | 4-digit year | 2024 |
%m | 2-digit month | 05 |
%d | 2-digit day | 20 |
%H | Hour (24h) | 14 |
%M | Minute | 30 |
%S | Second | 15 |
%z | UTC offset | +0000 |
%Z | Time zone name | UTC |
%a | Weekday (short) | Mon |
%A | Weekday (full) | Monday |
Example:
from datetime import datetime, timezone
dt = datetime(2024, 5, 20, 14, 30, 15, tzinfo=timezone.utc)
formatted = dt.strftime("%Y-%m-%d %H:%M:%S %Z")
print(formatted) # 2024-05-20 14:30:15 UTCBackend example: create a human readable timestamp for logs or emails, but still use ISO 8601 for APIs.
Parsing strings with `strptime`
Use strptime to parse a string into a datetime, using the same format codes.
from datetime import datetime
s = "2024-05-20 14:30:15"
dt = datetime.strptime(s, "%Y-%m-%d %H:%M:%S")
print(dt) # 2024-05-20 14:30:15
If the string contains a time zone offset, include %z:
s = "2024-05-20T14:30:15+00:00"
dt = datetime.strptime(s, "%Y-%m-%dT%H:%M:%S%z")
print(dt.tzinfo) # UTC offset
Backend example: parse a date string from a user form, such as 2024-05-20, into a date.
Doing Date and Time Arithmetic
You often need to calculate future or past times, durations, or differences between timestamps. For this, use timedelta.
Creating and using `timedelta`
timedelta represents a duration:
from datetime import timedelta
one_day = timedelta(days=1)
two_hours = timedelta(hours=2)
thirty_minutes = timedelta(minutes=30)Adding and subtracting
from datetime import datetime, timezone, timedelta
now = datetime.now(timezone.utc)
tomorrow = now + timedelta(days=1)
yesterday = now - timedelta(days=1)Backend example: generate a token that expires in 15 minutes:
from datetime import datetime, timezone, timedelta
def generate_expiry(minutes=15):
return datetime.now(timezone.utc) + timedelta(minutes=minutes)
expires_at = generate_expiry()Difference between two datetimes
from datetime import datetime, timezone
start = datetime(2024, 5, 20, 10, 0, tzinfo=timezone.utc)
end = datetime(2024, 5, 20, 12, 30, tzinfo=timezone.utc)
delta = end - start
print(delta) # 2:30:00
print(delta.total_seconds()) # 9000.0
total_seconds() is very useful when you need to convert durations to seconds, for example for timeout values.
Comparing datetimes
You can compare datetimes using <, <=, >, >=, ==, !=.
Only compare datetimes that are either both naive, or both aware with compatible time zones. Never mix naive and aware datetimes.
Incorrect comparison raises a TypeError:
from datetime import datetime, timezone
naive = datetime.now()
aware = datetime.now(timezone.utc)
# This will raise TypeError
# print(naive < aware)Backend example: check if a token is expired:
from datetime import datetime, timezone
def is_expired(expires_at: datetime) -> bool:
# assume expires_at is an aware UTC datetime
return datetime.now(timezone.utc) >= expires_atWorking with Unix Timestamps
A Unix timestamp is the number of seconds since the Unix epoch, which is defined as 1970-01-01 00:00:00 UTC.
Timestamps are common in databases, caches, and some APIs.
Datetime to timestamp
from datetime import datetime, timezone
dt = datetime(2024, 5, 20, 14, 30, 15, tzinfo=timezone.utc)
ts = dt.timestamp()
print(ts) # e.g. 1716215415.0For integer seconds:
ts_int = int(dt.timestamp())Timestamp to datetime
from datetime import datetime, timezone
ts = 1716215415
dt = datetime.fromtimestamp(ts, tz=timezone.utc)
print(dt) # 2024-05-20 14:30:15+00:00Backend example: store expiry times in Redis as Unix timestamps, and convert to datetime when needed.
Date and Time in Backend APIs
When building backend services, you must decide how to represent dates and times between:
- Database
- Backend code (Python)
- API responses and requests (JSON)
Common patterns
A common and safe pattern:
- Store datetimes in the database in UTC
- Use timezone-aware
datetimeobjects in Python withtimezone.utc - Serialize to ISO 8601 strings for JSON
Example FastAPI endpoint returning a timestamp:
from datetime import datetime, timezone, timedelta
from fastapi import FastAPI
app = FastAPI()
@app.get("/token")
def get_token():
now = datetime.now(timezone.utc)
expires_at = now + timedelta(minutes=15)
return {
"token": "example",
"issued_at": now.isoformat(),
"expires_at": expires_at.isoformat(),
}Example of reading a datetime from a request payload with Pydantic:
from datetime import datetime
from pydantic import BaseModel
class Event(BaseModel):
name: str
# Pydantic can parse ISO 8601 strings into datetime automatically
start_time: datetime
# In a FastAPI endpoint, Event will parse the incoming JSON stringAvoiding common mistakes
Some common pitfalls:
- Mixing naive and aware datetimes
- Storing local time instead of UTC in the database
- Ignoring time zones when parsing user input
- Returning ambiguous date formats like
"05/06/2024"that can be interpreted differently by region
Preferred JSON datetime format in backends:
Use ISO 8601 UTC strings such as "2024-05-20T14:30:15Z" for API request and response data.
Practical Examples for Backend Use Cases
Example: Generating expiration dates
Token that expires in 1 hour, stored in database:
from datetime import datetime, timezone, timedelta
def generate_token_data():
issued_at = datetime.now(timezone.utc)
expires_at = issued_at + timedelta(hours=1)
return issued_at, expires_atExample: Calculating age from birthdate
from datetime import date
def calculate_age(birthdate: date, today: date | None = None) -> int:
if today is None:
today = date.today()
years = today.year - birthdate.year
# Adjust if birthday has not occurred yet this year
if (today.month, today.day) < (birthdate.month, birthdate.day):
years -= 1
return yearsExample: Scheduling a reminder 24 hours before an event
from datetime import datetime, timezone, timedelta
def reminder_time(event_start: datetime) -> datetime:
# assume event_start is aware UTC datetime
return event_start - timedelta(hours=24)
event_start = datetime(2024, 6, 1, 10, 0, tzinfo=timezone.utc)
print(reminder_time(event_start))Summary
Working correctly with date and time is critical in backend development. The most important practical rules:
- Use timezone aware
datetimeobjects withtimezone.utcin your backend. - Store all datetimes in the database in UTC.
- Use ISO 8601 strings for JSON APIs.
- Use
timedeltafor durations and arithmetic. - Never mix naive and aware datetimes.
If you follow these rules and use the datetime module correctly, your backend will handle time reliably, even across different time zones and daylight saving changes.
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!