6.9. Templates
Table of Contents
Why Templates Matter
When you build web backends, you often need to send HTML pages to the browser. You could build HTML strings by hand in your Python code, but that becomes messy very quickly.
Templates solve this problem.
A template is an HTML file that contains small placeholders for dynamic data. Your backend fills those placeholders with real values at runtime, and sends the final HTML to the client.
Very informally:
- Template: a blueprint with holes.
- Data: the values that fill the holes.
- Rendered page: the final HTML that goes to the browser.
This chapter focuses on the general idea of templates and typical template engines, not on a specific framework. Later, when you use FastAPI or another framework, you will apply the same ideas with its own tools.
Key idea: A template engine takes template + data and produces HTML:
$$\text{rendered\_html} = \text{template\_engine}(\text{template}, \text{data})$$
Static HTML vs Templates
Static HTML
A static HTML file is just plain HTML. It does not change unless you edit the file.
Example: about.html:
<!DOCTYPE html>
<html>
<head>
<title>About our site</title>
</head>
<body>
<h1>About</h1>
<p>This is a static page.</p>
</body>
</html>Every visitor sees the exact same content.
Static HTML is fine for:
- Simple marketing pages
- Documentation that does not change often
- Assets like CSS and JavaScript files
Dynamic HTML with Templates
For a typical application, content depends on:
- The user that is logged in
- Data from the database
- Current time, settings, or request parameters
Creating such pages by hand in Python is painful:
def user_profile_page(user):
return (
"<html><body>"
"<h1>Profile for " + user["name"] + "</h1>"
"<p>Age: " + str(user["age"]) + "</p>"
"</body></html>"
)Problems:
- Hard to read
- Easy to break HTML
- Hard to maintain large pages
Templates let you write HTML like normal, but with placeholders for the dynamic parts:
<h1>Profile for {{ user.name }}</h1>
<p>Age: {{ user.age }}</p>
The backend then renders this with a dictionary like {"user": user}.
What Is a Template Engine?
A template engine is a library that:
- Reads a template file with placeholders
- Replaces placeholders with real values you provide
- Returns the final string, usually HTML
Popular template engines:
| Language | Common template engines |
|---|---|
| Python | Jinja2, Django Templates, Mako |
| JavaScript (node) | Handlebars, EJS, Pug |
| PHP | Blade (Laravel), Twig |
You do not need to remember all of these. You just need to understand:
A template engine uses a template language with special syntax (like {{ ... }}) to:
- insert values
- repeat blocks
- conditionally show or hide content
We will use a Jinja-like syntax in examples, because many Python frameworks use it or something very similar.
Basic Template Syntax: Variables
The most basic thing in a template is a variable. This is data that your backend passes to the template.
In many engines, variables are written like this:
<p>Hello, {{ name }}!</p>When you render the template with:
data = {"name": "Alice"}The final HTML becomes:
<p>Hello, Alice!</p>Another example:
Template user.html:
<h1>User: {{ user.username }}</h1>
<p>Email: {{ user.email }}</p>
<p>Joined: {{ user.joined_at }}</p>Rendered with:
data = {
"user": {
"username": "bob",
"email": "bob@example.com",
"joined_at": "2026-08-27"
}
}Result:
<h1>User: bob</h1>
<p>Email: bob@example.com</p>
<p>Joined: 2026-08-27</p>Most engines let you access:
- dictionary keys:
user["username"]often appears asuser.username - object attributes:
user.usernamedirectly - list items:
items[0]
Conditions in Templates
Templates often need to show content only if something is true. For example, show a "Login" link only if the user is anonymous.
Template engines usually support if statements.
Example:
{% if user.is_logged_in %}
<p>Welcome back, {{ user.name }}!</p>
<a href="/logout">Logout</a>
{% else %}
<p>Hello, guest!</p>
<a href="/login">Login</a>
{% endif %}Here
{% ... %}is for control statements such asif,for, etc.{{ ... }}is for inserting values.
Another example with multiple branches:
{% if cart.total_items == 0 %}
<p>Your cart is empty.</p>
{% elif cart.total_items == 1 %}
<p>You have 1 item in your cart.</p>
{% else %}
<p>You have {{ cart.total_items }} items in your cart.</p>
{% endif %}You pass something like:
{"cart": {"total_items": 3}}The HTML will show:
<p>You have 3 items in your cart.</p>Loops in Templates
You often want to display lists of things:
- list of products
- list of blog posts
- list of error messages
Templates provide for loops to repeat a block for each item.
Example: product list
<ul>
{% for product in products %}
<li>
{{ product.name }} - ${{ product.price }}
</li>
{% endfor %}
</ul>Data:
{
"products": [
{"name": "Keyboard", "price": 39.99},
{"name": "Mouse", "price": 19.99},
{"name": "Monitor", "price": 199.99},
]
}Rendered HTML:
<ul>
<li>
Keyboard - $39.99
</li>
<li>
Mouse - $19.99
</li>
<li>
Monitor - $199.99
</li>
</ul>You can also combine loops and conditions:
<ul>
{% for product in products %}
{% if product.in_stock %}
<li>{{ product.name }} is in stock!</li>
{% else %}
<li>{{ product.name }} is out of stock.</li>
{% endif %}
{% endfor %}
</ul>This lets you keep logic that affects display only inside the template.
Template Inheritance and Layouts
Real websites usually have:
- the same
<head>section - the same header and footer
- the same navigation menu
Copying this HTML into every file is tedious and error prone.
Template engines usually support template inheritance so you can define a base layout and extend it.
Base Template
Example: base.html:
<!DOCTYPE html>
<html>
<head>
<title>{% block title %}My Site{% endblock %}</title>
<link rel="stylesheet" href="/static/styles.css">
</head>
<body>
<header>
<h1>My Site</h1>
<nav>
<a href="/">Home</a>
<a href="/products">Products</a>
<a href="/about">About</a>
</nav>
</header>
<main>
{% block content %}{% endblock %}
</main>
<footer>
<p>© {{ current_year }} My Company</p>
</footer>
</body>
</html>Here we define blocks:
titleblockcontentblock
Child templates fill in these blocks.
Child Templates
Example: home.html:
{% extends "base.html" %}
{% block title %}Home | My Site{% endblock %}
{% block content %}
<h2>Welcome</h2>
<p>This is the homepage.</p>
{% endblock %}
Example: products.html:
{% extends "base.html" %}
{% block title %}Products | My Site{% endblock %}
{% block content %}
<h2>Products</h2>
<ul>
{% for product in products %}
<li>{{ product.name }} - ${{ product.price }}</li>
{% endfor %}
</ul>
{% endblock %}The template engine:
- starts with
base.html - replaces the block contents with the child template content
- produces the final HTML
This keeps your layouts consistent, and makes it easy to change a header or footer in one place.
Escaping and Security in Templates
When you insert user data into HTML, you must think about security, especially Cross-Site Scripting (XSS). Many template engines automatically escape values to prevent HTML or JavaScript from being interpreted.
For example, suppose a malicious user name is:
<script>alert('hacked');</script>If your template is:
<p>User: {{ user.name }}</p>A safe template engine will escape the special characters and output:
<p>User: <script>alert('hacked');</script></p>So the browser shows the text instead of executing the script.
Important rule: Never disable auto escaping for untrusted input. If you mark data as "safe" in the template, do it only for data you created yourself, not from users.
Most engines also provide filters for formatting, such as:
- Dates:
{{ date_value | date("Y-m-d") }}or similar - Length:
{{ items | length }} - Uppercase:
{{ name | upper }}
Exact syntax depends on the engine, but the idea is the same.
Directory Structure for Templates
Frameworks usually expect templates in a specific directory. A common layout:
project/
app.py # your backend code
templates/
base.html
home.html
users/
list.html
detail.html
static/
styles.css
app.jsTypical patterns:
- A global
templatesfolder - Subfolders for each part of your application
users/list.htmlusers/detail.htmlproducts/list.html
Frameworks then have a function like render_template("users/list.html", data).
Passing Data from Backend to Templates
Even though this chapter focuses on templates in general, it is useful to see what it looks like to call the engine from Python. The exact code will differ per framework, but the pattern is always similar.
You usually:
- Prepare your data in Python
- Call a render function with the name of the template and a context dict
A generic example:
def user_list_endpoint(request):
# 1. Load users from database
users = [
{"id": 1, "name": "Alice"},
{"id": 2, "name": "Bob"},
]
# 2. Render template with data
html = render_template("users/list.html", {"users": users})
# 3. Return HTML as a response
return HTMLResponse(html)
Template users/list.html:
<h1>Users</h1>
<ul>
{% for user in users %}
<li>
<a href="/users/{{ user.id }}">{{ user.name }}</a>
</li>
{% endfor %}
</ul>Rendered example:
<h1>Users</h1>
<ul>
<li>
<a href="/users/1">Alice</a>
</li>
<li>
<a href="/users/2">Bob</a>
</li>
</ul>Using Templates with Forms
Templates are also useful for displaying forms and showing validation errors.
Simple Login Form Template
Template auth/login.html:
<h1>Login</h1>
{% if error %}
<p style="color: red;">{{ error }}</p>
{% endif %}
<form method="post" action="/login">
<label>
Email:
<input type="email" name="email" value="{{ form.email }}">
</label>
<br>
<label>
Password:
<input type="password" name="password">
</label>
<br>
<button type="submit">Login</button>
</form>Backend flow could be:
- GET
/login - Render the template with empty
formand noerror. - POST
/login - Validate the credentials.
- If invalid, render the template again, with:
error: an error messageform.email: the email the user entered
Example context on error:
{
"error": "Invalid email or password",
"form": {"email": "user@example.com"}
}The template shows the error and keeps the email field filled.
When to Use Templates vs JSON APIs
Not every backend uses templates. Some backends only serve JSON to frontend applications built in React, Vue, or mobile apps.
A quick comparison:
| Approach | What backend returns | Typical client |
|---|---|---|
| Templates | Ready HTML pages | Browser |
| JSON API | JSON data | Single Page Apps, apps |
You often:
- Use templates for classic server rendered websites (blog, admin panel, simple apps).
- Use JSON APIs for more dynamic or mobile heavy applications.
You can also combine both. For example:
- Use templates for an admin panel.
- Use JSON endpoints for your public API.
Understanding templates is important even if you plan to build APIs. Many admin interfaces, dashboards, and internal tools still use server rendered templates.
Common Pitfalls and Best Practices
Keep Business Logic Out of Templates
Templates are for presentation. They should not contain complex business rules.
Bad pattern:
{% if user.balance > 1000 and user.country in ["US", "UK"] and discounts_enabled %}
<p>You are a premium customer!</p>
{% endif %}Better:
- Calculate a flag
is_premiumin Python. - Pass it to the template.
is_premium = user.balance > 1000 and user.country in ["US", "UK"] and discounts_enabled
context = {"user": user, "is_premium": is_premium}Template:
{% if is_premium %}
<p>You are a premium customer!</p>
{% endif %}Use Template Inheritance
Do not repeat your header, footer, or menu in every template. Put them in a base template and extend it.
Avoid Building HTML by Hand in Python
If you see a lot of string concatenation in your backend to build HTML, move it to a template.
Do Not Trust User Content
Let the template engine escape values by default. Only mark content as safe if you are sure it does not contain harmful HTML or JavaScript.
Summary
In this chapter you learned:
- What templates are and why they are useful for building dynamic HTML pages.
- How template engines work with variables, conditions, and loops.
- How template inheritance lets you create a common layout.
- How to pass data from backend code to templates.
- How templates interact with forms and how to avoid common mistakes.
Later, when you work with specific frameworks like FastAPI, you will use these concepts with their built in tools to render HTML pages from 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!