18.3. Sending Emails
Table of Contents
Why Sending Emails Matters in Backend Development
Most real applications need to send emails. Examples:
- Signup confirmation emails
- Password reset links
- Order confirmations and invoices
- Notifications (comment replies, status changes, alerts)
Backend code is usually responsible for triggering and sending these emails, often using an external email service.
This chapter focuses on how to actually send emails from backend code, what information an email needs, and how to avoid common pitfalls. It assumes you already understand the basics of “How Email Works” and “SMTP”.
Key idea: Your backend rarely sends email “directly” to the recipient. It usually hands the email to an SMTP server or email API, which then delivers it.
Core Concepts: What You Need To Send an Email
To send an email from a backend application, you always need three things:
- Transport configuration
How and where to send the email, for example: - SMTP server hostname, port, username, password
- Or an HTTP API endpoint and API key (like SendGrid, Mailgun)
- Message data
The content and metadata of the email: - From address
- To addresses
- Subject
- Body (plain text and/or HTML)
- Optional: CC, BCC, Reply-To, attachments, headers
- Client library or implementation
Something that connects to the SMTP server or email API and passes the message.
A simple mental model:
| Step | Question | Example answer |
|---|---|---|
| 1 | Where do I send this email? | smtp.gmail.com:587 with user and password |
| 2 | What is the email content? | From: app@example.com, To: you@example.com |
| 3 | How do I send it? | Use smtplib in Python, or a service’s SDK |
Email Message Structure in Practice
An email message can be split into:
- Headers: metadata
- Body: the actual content, which can be:
- Plain text
- HTML
- Multipart (both text and HTML, plus attachments)
Example raw email structure (simplified):
From: "My App" <no-reply@myapp.com>
To: alice@example.com
Subject: Welcome to My App!
MIME-Version: 1.0
Content-Type: text/plain; charset="utf-8"
Hello Alice,
Welcome to My App!
Thanks,
The My App TeamFor HTML:
Content-Type: text/html; charset="utf-8"
<html>
<body>
<p>Hello <b>Alice</b>,</p>
<p>Welcome to <strong>My App</strong>!</p>
</body>
</html>Most real emails are multipart and include both text and HTML so that:
- Modern clients show HTML.
- Text-only clients still show something readable.
Sending Emails with SMTP (Conceptual Flow)
When your backend sends an email via SMTP, this is the simplified sequence:
- Open a connection to the SMTP server (for example
smtp.example.comon port587). - Start TLS encryption if required.
- Authenticate with a username and password or special SMTP credentials.
- Provide sender and recipients.
- Send the message content.
- Close the connection.
In pseudocode:
connect_to_smtp(server, port)
use_tls()
login(username, password)
send_mail(from_address, to_addresses, message)
disconnect()Important rule: Never hard-code SMTP passwords or API keys in your code. Store them in environment variables or a secrets manager.
A Minimal Python SMTP Example
This example shows a simple email send using Python’s standard library. In a real project you would move this into a function or a dedicated module.
import smtplib
from email.message import EmailMessage
SMTP_HOST = "smtp.example.com"
SMTP_PORT = 587
SMTP_USER = "smtp-user"
SMTP_PASSWORD = "smtp-password"
def send_welcome_email(recipient_email: str) -> None:
msg = EmailMessage()
msg["From"] = "My App <no-reply@myapp.com>"
msg["To"] = recipient_email
msg["Subject"] = "Welcome to My App!"
msg.set_content(
"Hello,\n\n"
"Welcome to My App!\n\n"
"Thanks,\n"
"The My App Team"
)
# Optional HTML alternative
msg.add_alternative(
"""\
<html>
<body>
<p>Hello,</p>
<p>Welcome to <strong>My App</strong>!</p>
<p>Thanks,<br>The My App Team</p>
</body>
</html>
""",
subtype="html"
)
with smtplib.SMTP(SMTP_HOST, SMTP_PORT) as smtp:
smtp.starttls()
smtp.login(SMTP_USER, SMTP_PASSWORD)
smtp.send_message(msg)Key points:
EmailMessagetakes care of proper MIME formatting.set_contentsets the plain text.add_alternativeadds HTML, so the email becomes multipart.starttls()ensures data is encrypted between your app and the SMTP server.
Using an Email Service Provider (API-Based)
Many production systems use Email Service Providers (ESPs) instead of raw SMTP, for example:
- SendGrid
- Mailgun
- Amazon SES
- Postmark
Common advantages:
- Better deliverability
- Tracking (opens, clicks, bounces)
- Email templates
- Rate limiting and scaling
- Web dashboards and logs
Typical workflow:
- Create an account and verify your domain.
- Get an API key.
- Use the provider’s HTTP API or SDK from your backend.
A very generic example of sending an email via a fictitious email API:
import requests
API_KEY = "your-api-key"
API_URL = "https://api.emailservice.com/v1/send"
def send_reset_email(to_email: str, reset_link: str) -> None:
data = {
"from": "My App <no-reply@myapp.com>",
"to": [to_email],
"subject": "Reset your password",
"text": f"Click this link to reset your password: {reset_link}",
"html": f"<p>Click <a href='{reset_link}'>this link</a> to reset your password.</p>",
}
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json",
}
response = requests.post(API_URL, json=data, headers=headers)
response.raise_for_status()You do not need to manage SMTP details here. The provider handles them.
Generating Dynamic Email Content
Most application emails contain dynamic data, for example:
- User name
- Order details
- One-time tokens
- Custom messages
Instead of building strings by hand, you usually use templates, similar to HTML templates for web pages.
Simple string formatting:
body = (
"Hello {name},\n\n"
"Your order #{order_id} has been shipped.\n"
"Track it here: {tracking_url}\n\n"
"Thanks,\n"
"The Store Team"
).format(
name=user_name,
order_id=order_id,
tracking_url=tracking_url,
)Template example using a Jinja2-style template (conceptually):
<!-- order_shipped_email.html -->
<p>Hello {{ name }},</p>
<p>Your order <strong>#{{ order_id }}</strong> has been shipped.</p>
<p>You can track it here: <a href="{{ tracking_url }}">{{ tracking_url }}</a></p>
<p>Thanks,<br>The Store Team</p>Pseudocode rendering:
html_body = template_engine.render(
"order_shipped_email.html",
{"name": name, "order_id": order_id, "tracking_url": tracking_url},
)This keeps your email designs out of your Python code and makes them easier to edit.
Handling Common Email Fields
Backend code should know when and how to use these fields:
| Field | Purpose | Example |
|---|---|---|
| From | Sender address, often no-reply | My App <no-reply@myapp.com> |
| To | Main recipient(s) | alice@example.com |
| CC | Visible copy to others | manager@example.com |
| BCC | Hidden copy to others | audit@example.com |
| Reply-To | Address that gets replies | support@myapp.com |
| Subject | Short summary | Your order has shipped |
Example of adding CC and BCC with EmailMessage:
msg["From"] = "My App <no-reply@myapp.com>"
msg["To"] = "alice@example.com"
msg["Cc"] = "manager@example.com"
msg["Bcc"] = "audit@example.com"
msg["Subject"] = "Monthly report"
Note that some libraries treat BCC separately. For SMTP, recipients in Bcc must still be passed to the SMTP client, even if the header is not visible in the message.
Attachments (High-Level Overview)
Sometimes you need to send files:
- PDF invoices
- CSV exports
- Images
Conceptually:
- Load file content.
- Attach it to the email with a MIME type and a filename.
Python example:
from email.message import EmailMessage
from pathlib import Path
def send_invoice_email(to_email: str, invoice_path: Path) -> None:
msg = EmailMessage()
msg["From"] = "Billing <billing@myapp.com>"
msg["To"] = to_email
msg["Subject"] = "Your invoice"
msg.set_content("Please find your invoice attached.")
file_bytes = invoice_path.read_bytes()
msg.add_attachment(
file_bytes,
maintype="application",
subtype="pdf",
filename=invoice_path.name,
)
# Send via SMTP (omitting boilerplate for brevity)Make sure you respect file size limits and security rules from the “Working with Files” and “File Upload Security” topics.
Testing Email Sending During Development
Sending real emails every time during development is slow and can be unsafe. Use these approaches:
- Local SMTP debug server
Many languages and frameworks allow you to run a dummy SMTP server that prints emails to the console or a UI instead of delivering them.
Example with Python (from command line):
python -m smtpd -c DebuggingServer -n localhost:1025Then configure your app:
SMTP_HOST = "localhost"
SMTP_PORT = 1025- Sandbox mode / test mode
Many email providers offer a sandbox mode where emails are not actually sent to real inboxes. - Log-only mode
For development, you can log email content instead of sending it:
def send_email(msg: EmailMessage) -> None:
if settings.ENV == "development":
print("EMAIL WOULD BE SENT:")
print(msg)
return
# production sending logic hereImportant rule: Never send real user emails for automated tests or local development. Use test addresses or sandbox modes.
Handling Errors and Retries
Email sending can fail for several reasons:
- Network issues
- Wrong credentials
- Provider limits or errors
- Invalid recipient addresses
In code you should:
- Catch exceptions around the send call.
- Log the error with enough context.
- Decide whether to:
- Show a friendly message to the user.
- Queue the email for retry in a background job.
- Mark email as failed in the database.
Simple pattern:
import logging
logger = logging.getLogger(__name__)
def send_email_safe(msg: EmailMessage) -> bool:
try:
# send via SMTP or API here
return True
except Exception as exc:
logger.exception("Failed to send email to %s", msg["To"])
return FalseIn a production system, email sending is frequently moved to background jobs, so slow or failing email does not block user-facing requests. That connects directly to the “Background Processing” section in this course.
Configuration and Environment Separation
You will often run your application in different environments:
developmentstagingproduction
Each environment can have different:
- SMTP host and port.
- Credentials.
- Sender email addresses.
- Email provider accounts.
Typical configuration table:
| Environment | SMTP/Provider | Example from address |
|---|---|---|
| Dev | Local debug SMTP | dev-no-reply@myapp.local |
| Staging | Provider sandbox account | staging@myapp.com |
| Prod | Provider production account | no-reply@myapp.com |
Keep them in environment variables:
EMAIL_HOST=smtp.example.com
EMAIL_PORT=587
EMAIL_USER=myapp-smtp-user
EMAIL_PASSWORD=super-secret
EMAIL_FROM="My App <no-reply@myapp.com>"Then load them in code. This keeps secrets out of your repository and makes deployments configurable.
Putting It All Together: A Simple Email Service Class
This is a more structured example you might use in a backend project:
import smtplib
from email.message import EmailMessage
class EmailService:
def __init__(self, host: str, port: int, user: str, password: str, default_from: str):
self.host = host
self.port = port
self.user = user
self.password = password
self.default_from = default_from
def send(
self,
to: list[str],
subject: str,
text_body: str,
html_body: str | None = None,
from_address: str | None = None,
) -> None:
msg = EmailMessage()
msg["From"] = from_address or self.default_from
msg["To"] = ", ".join(to)
msg["Subject"] = subject
msg.set_content(text_body)
if html_body:
msg.add_alternative(html_body, subtype="html")
with smtplib.SMTP(self.host, self.port) as smtp:
smtp.starttls()
smtp.login(self.user, self.password)
smtp.send_message(msg)
# Usage example
email_service = EmailService(
host="smtp.example.com",
port=587,
user="smtp-user",
password="smtp-password",
default_from="My App <no-reply@myapp.com>",
)
email_service.send(
to=["alice@example.com"],
subject="Welcome!",
text_body="Hello Alice,\nWelcome to My App!",
html_body="<p>Hello <b>Alice</b>,</p><p>Welcome to My App!</p>",
)This keeps email sending logic in one place and makes it easier to:
- Switch from SMTP to an email provider API later.
- Mock the service in tests.
- Centralize logging and error handling.
Summary
In backend applications, sending emails involves:
- Configuring an SMTP server or an email provider API.
- Building structured email messages with headers, text, HTML, and sometimes attachments.
- Using templates to generate dynamic content.
- Separating configuration per environment and keeping secrets safe.
- Testing email sending without spamming real users.
- Handling errors and, in production, moving email sending to background jobs.
With these concepts, you can implement welcome emails, password resets, order confirmations, and other common email features in backend systems.
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!