17.6. Scheduled Tasks
Table of Contents
Why Scheduled Tasks Matter
In many backend systems, some work should run at a specific time or repeatedly, not directly in response to a user request. These are scheduled tasks.
Typical examples:
- Send a daily summary email to users at 08:00.
- Clean up old sessions every hour.
- Recalculate statistics every night.
- Sync data with an external API every 5 minutes.
- Generate a backup at midnight.
Doing this inside normal HTTP request handlers is a bad idea. An HTTP request is short lived, but these tasks must run reliably and often when no user is online. Scheduled tasks solve this.
Key idea: A scheduled task is a job that runs automatically at a given time or interval, independent of any single HTTP request.
Scheduled tasks are usually built on top of background jobs and workers, which you met in earlier sections. The scheduler decides when to enqueue a job, and the workers decide how to run it.
Types of Scheduled Tasks
Time based vs Event based
There are two broad ways to think about scheduled work:
- Time based scheduling
Run at a specific time or interval. Examples: - Every day at 03:00, run
cleanup_old_orders. - Every 5 minutes, run
sync_with_payment_gateway. - Once at a specific date, send a release announcement.
- Event based scheduling
Triggered by an event, not by the clock: - When a user registers, send a welcome email after 10 minutes.
- When an order is paid, recheck payment status after 1 hour.
This is still a form of scheduling, because you set a task to run in the future, but it is not tied to a fixed time like “every day at midnight.”
Both types can use the same tools. The scheduler library usually supports:
- “Run every N minutes.”
- “Run at 03:00 every day.”
- “Run at this exact timestamp in the future.”
One time vs Recurring
Another useful distinction:
- One time tasks
Scheduled to run once in the future, then never again.
Example: Remind user about an expiring subscription 7 days from now. - Recurring tasks
Scheduled to run repeatedly with a pattern.
Examples: - Every Monday at 09:00.
- Every 10 minutes, forever.
Table comparison:
| Aspect | One time task | Recurring task |
|---|---|---|
| Trigger | Specific date/time once | Interval or cron-like schedule |
| Example | “Run at 2026-12-31 23:59:00” | “Run every day at 04:00” |
| Common use | Reminders, delayed notifications | Maintenance, reports, data sync |
Scheduling with Cron
Before Python tools, it is important to know the classic Unix solution: cron.
What is cron?
On Linux and many Unix systems, cron is a built-in scheduler that runs commands at specified times. A backend application can use cron to:
- Run a script every night.
- Call a management command every hour.
- Trigger backups.
You define tasks in a crontab (cron table).
Basic crontab line format:
* * * * * command to run
| | | | |
| | | | +----- day of week (0-7, Sunday is 0 or 7)
| | | +------- month (1-12)
| | +--------- day of month (1-31)
| +----------- hour (0-23)
+------------- minute (0-59)
Cron pattern:
minute hour day-of-month month day-of-week
Cron timing examples
| Schedule | Cron expression |
|---|---|
| Every minute | * |
| Every day at 03:00 | 0 3 * |
| Every Monday at 09:30 | 30 9 1 |
| Every 15 minutes | /15 * |
| At 00:00 on the 1st of each month | 0 0 1 |
You can test your understanding. For example:
- “Every day at 18:45” →
45 18 * - “Every 5 minutes during working hours (09:00 to 17:59)” →
/5 9-17
Cron then runs the command you specify at those times.
Example: Running a Python script with cron
Imagine you have a Python script:
# cleanup_sessions.sh
#!/usr/bin/env bash
cd /path/to/app
source venv/bin/activate
python -m app.scripts.cleanup_sessionsYou can schedule it:
0 * * * * /path/to/cleanup_sessions.sh >> /var/log/cleanup.log 2>&1This runs the script at the start of every hour and appends output to a log file.
Pros and cons of cron
Pros:
- Already available on most Linux servers.
- Very simple to set up.
- Works with any language or command.
Cons:
- Limited visibility from your Python app, cron is external.
- Harder to scale across many servers safely.
- No built-in retries or job tracking.
- Time zone handling is manual.
Cron is fine for small projects or for system-level tasks like backups. For application-level tasks that need to integrate with your database and message queues, Python based schedulers are usually better.
Scheduling in Python
Instead of system level cron, you can use Python libraries that run inside your application environment. Common patterns:
- Use a task queue (like Celery with Redis) and a scheduler component.
- Use a standalone scheduler library (like APScheduler) to run Python functions at certain times.
Important separation:
Often the scheduler just enqueues jobs, and workers execute jobs.
Do not execute heavy logic directly inside the scheduler loop.
Celery beat: scheduling Celery tasks
If you use Celery for background jobs, Celery beat is the scheduler component.
Architecture:
- You define Celery tasks in your application.
- You define a beat schedule that says when to run which task.
- Celery beat periodically sends tasks to the broker (for example Redis).
- Celery workers pick up and execute those tasks.
Basic Celery task
# tasks.py
from celery import Celery
app = Celery("myapp", broker="redis://localhost:6379/0")
@app.task
def cleanup_sessions():
print("Cleaning up expired sessions...")
# logic hereDefining periodic tasks
You can define schedule in Python:
from celery.schedules import crontab
app.conf.beat_schedule = {
"cleanup-sessions-every-hour": {
"task": "tasks.cleanup_sessions",
"schedule": crontab(minute=0), # every hour at minute 0
},
}Or using intervals:
app.conf.beat_schedule = {
"sync-stats-every-5-minutes": {
"task": "tasks.sync_stats",
"schedule": 300.0, # seconds
},
}Running beat and workers
Typically, you run:
celery -A tasks worker --loglevel=info
celery -A tasks beat --loglevel=infoin two different processes or containers.
This keeps scheduling and execution separated.
Adding one time tasks
Celery can also handle delayed one time tasks, for example:
# schedule to run 10 minutes later
from datetime import timedelta
cleanup_sessions.apply_async(countdown=600)This is more event based, as described earlier.
APScheduler
APScheduler is a pure Python scheduling library. It is often used in:
- Standalone Python services.
- Application servers with a long running process.
It supports multiple trigger types:
- Interval: run every N seconds/minutes/hours.
- Cron: run at times similar to Unix cron.
- Date: one time execution at a specific datetime.
Basic APScheduler example
from datetime import datetime
from apscheduler.schedulers.background import BackgroundScheduler
def send_daily_report():
print(f"Sending daily report at {datetime.utcnow()}")
scheduler = BackgroundScheduler()
# Run every day at 08:00 UTC
scheduler.add_job(
send_daily_report,
trigger="cron",
hour=8,
minute=0
)
scheduler.start()
# Keep your main program alive
try:
while True:
pass
except KeyboardInterrupt:
scheduler.shutdown()
This will call send_daily_report every day at 08:00 UTC.
Trigger types in APScheduler
| Trigger | Description | Example |
|---|---|---|
date | Run once at a given datetime | “At 2026-01-01 00:00” |
interval | Run every N time units | “Every 10 minutes” |
cron | Cron style schedule | “At 03:00 every day” |
Example of an interval job:
# Every 5 minutes
scheduler.add_job(
sync_external_api,
trigger="interval",
minutes=5
)Example of a one time job:
from datetime import datetime, timedelta
run_at = datetime.utcnow() + timedelta(days=7)
scheduler.add_job(
remind_subscription,
trigger="date",
run_date=run_at,
args=[user_id]
)APScheduler with web frameworks
If you run APScheduler inside a web app (for example FastAPI), remember:
- The scheduler must be started once when the app starts.
- The scheduler process must always be running somewhere.
- In multi instance deployments, running the same scheduler in many instances can cause duplicate jobs. You must handle that with:
- Only one instance running the scheduler, or
- Use APScheduler with a shared job store and coordination, or
- Use a centralized queue like Celery instead of APScheduler for production grade scheduling.
Time Zones and Daylight Saving Time
Scheduling across time zones is tricky. If your system has users around the world, you must decide which time zone the scheduler uses.
Common options:
- Always schedule in UTC.
- For user specific schedules, store the user’s time zone and convert.
Best practice: Store and process times in UTC internally, convert to local time only at the edges (API / UI).
Example problem
You schedule a daily job at 02:30 local time. When daylight saving time (DST) starts or ends:
- The time 02:30 might not exist at all on that day, or
- The clock might jump backward from 02:59 to 02:00, causing ambiguity.
Libraries like APScheduler and Python’s zoneinfo (or pytz) can help, but you still need clear rules about what should happen.
Generally:
- For system wide maintenance jobs, pick UTC times that are stable.
- For user facing schedules, save:
- The intended local time, for example “9:00”.
- The user’s time zone, for example “Europe/Berlin”.
- Convert to UTC each time you calculate the next run.
Idempotency and Safety of Scheduled Jobs
If a scheduled job runs multiple times accidentally, what happens? This is common if:
- The job fails halfway and then is retried.
- Two scheduler instances misfire.
- A worker is slow and overlaps with the next scheduled run.
To keep your system safe, scheduled tasks should usually be idempotent.
Idempotent operation:
An operation is idempotent if running it multiple times has the same effect as running it once.
Non idempotent example
def send_billing_email(user_id):
# BAD: will send multiple copies if retried
email_service.send("Monthly bill", to=user_id)If this job is retried or accidentally scheduled twice, the user gets multiple emails.
More idempotent approach
You can track executions:
def send_billing_email(user_id, billing_period):
if has_already_sent_email(user_id, billing_period):
return # do nothing
email_service.send("Monthly bill", to=user_id)
mark_email_sent(user_id, billing_period)Now, even if the task is executed multiple times, only one email is sent.
Other common strategies:
- Use database constraints to avoid duplicate inserts.
- Use a lock, for example Redis lock or advisory lock in PostgreSQL, so that only one worker can execute a specific job instance at a time.
- Design cleanup tasks so repeated execution is harmless, for example always delete all rows older than a certain date.
Monitoring and Managing Scheduled Tasks
Scheduled jobs are long lived. They might run for months or years, so you need to:
- Log their execution.
- Detect when they fail.
- Observe how long they take.
- Make sure they do not overlap in dangerous ways.
Logging and metrics
For each scheduled task, log:
- Start time.
- End time or duration.
- Result (success or failure).
- Important parameters (for example date processed, user count, etc).
Example:
import logging
from datetime import datetime
logger = logging.getLogger(__name__)
def cleanup_sessions():
started_at = datetime.utcnow()
logger.info("cleanup_sessions started", extra={"started_at": started_at.isoformat()})
try:
removed = perform_cleanup()
logger.info(
"cleanup_sessions finished",
extra={"removed": removed, "started_at": started_at.isoformat()}
)
except Exception:
logger.exception("cleanup_sessions failed")
raiseYou can also expose metrics like:
- Number of successful runs.
- Number of failed runs.
- Average duration.
These metrics are very helpful when integrated with monitoring tools.
Avoiding overlapping executions
If a task is scheduled every 5 minutes, but sometimes takes 10 minutes to finish, you might have overlapping instances. That can:
- Overload your database.
- Cause inconsistent state.
Ways to prevent this:
- Use a lock (for example Redis, database advisory lock).
- Let the task check if another instance is running before it starts.
- Choose a schedule interval that is safely larger than the worst case runtime.
Example using a simple lock idea:
def run_with_lock(lock_key, func, *args, **kwargs):
if not acquire_lock(lock_key): # uses Redis or DB
return # lock is held, skip this run
try:
return func(*args, **kwargs)
finally:
release_lock(lock_key)Then:
def do_daily_aggregation():
run_with_lock("daily_aggregation_lock", _do_daily_aggregation_impl)Scheduled Tasks in Practice
To connect everything, here are a few realistic scenarios and how scheduling might look.
Daily cleanup with Celery beat
Goal: Remove users’ expired password reset tokens once per day.
- Define the task:
from celery import Celery
from datetime import datetime, timedelta
app = Celery("myapp", broker="redis://localhost:6379/0")
@app.task
def cleanup_password_reset_tokens():
expiration_time = datetime.utcnow() - timedelta(hours=24)
# Delete all tokens older than expiration_time
deleted = (
db_session.query(PasswordResetToken)
.filter(PasswordResetToken.created_at < expiration_time)
.delete()
)
db_session.commit()
print(f"Deleted {deleted} tokens")- Configure beat schedule:
from celery.schedules import crontab
app.conf.beat_schedule = {
"cleanup-password-reset-tokens-daily": {
"task": "tasks.cleanup_password_reset_tokens",
"schedule": crontab(hour=2, minute=0), # 02:00 UTC every day
},
}Now Celery beat schedules the task. Celery workers execute it.
User specific reminders with delayed tasks
Goal: Send a reminder email 3 days before a user’s subscription expires.
In the business logic when the user subscribes:
from datetime import timedelta
def on_user_subscribed(user_id, expires_at):
reminder_time = expires_at - timedelta(days=3)
now = datetime.utcnow()
delay_seconds = max(0, (reminder_time - now).total_seconds())
send_renewal_reminder.apply_async(
args=[user_id],
countdown=delay_seconds
)This sets a one time scheduled task for that user.
send_renewal_reminder is a Celery task that checks again that the subscription is still expiring before sending the email, which makes it safer and more idempotent.
Scheduled statistics with APScheduler
Goal: Recalculate daily statistics at midnight.
from apscheduler.schedulers.blocking import BlockingScheduler
scheduler = BlockingScheduler()
@scheduler.scheduled_job("cron", hour=0, minute=0)
def calculate_daily_stats():
# aggregate yesterday's data
pass
if __name__ == "__main__":
scheduler.start()You can deploy this as a separate service. It runs indefinitely and only does scheduling and stats.
Summary
- Scheduled tasks are jobs that run automatically at specific times or intervals.
- Unix cron is a simple, system level scheduler that runs commands on a schedule.
- Python libraries like Celery beat and APScheduler integrate scheduling with your application, task queues, and workers.
- Always think about time zones, daylight saving time, idempotency, and overlapping execution when designing scheduled tasks.
- Use logging and metrics so you can see what scheduled tasks are doing over time.
With these ideas, you can design backend systems that perform important work reliably and automatically, even when no user is making requests.
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!