6.6. Form Data
Table of Contents
Understanding Form Data in Web Backends
When users submit information through HTML forms, the browser sends that data to your backend in a specific format. This chapter focuses on how that format works and what is special about handling form data in a backend.
You will see simple, concrete examples, mostly with Python and FastAPI style, but the ideas apply to any backend framework or language.
What Is Form Data?
Form data is the information that a web browser sends to the server when a user submits an HTML <form>.
Typical examples:
- Login form:
username,password - Search form:
query - Contact form:
name,email,message - Settings form: many checkboxes and selects
An HTML form might look like this:
<form action="/login" method="post">
<input type="text" name="username">
<input type="password" name="password">
<button type="submit">Log in</button>
</form>
When the user clicks "Log in", the browser collects all inputs that have a name attribute and sends them to /login as form data.
Key points:
- The inputs must have a
name, not just anid. - Only enabled controls with a name are sent.
- The server sees a mapping of field names to values, similar to a dictionary or map.
For example, the submission above becomes something like:
username=alice&password=secret123which the backend parses into something like:
{
"username": "alice",
"password": "secret123"
}How Browsers Send Form Data
Method: GET vs POST
The method attribute in the <form> tells the browser which HTTP method to use.
<form action="/search" method="get">
<input type="text" name="q">
<button type="submit">Search</button>
</form><form action="/contact" method="post">
<input type="text" name="name">
<input type="email" name="email">
<textarea name="message"></textarea>
<button type="submit">Send</button>
</form>Differences:
| Method | Where data goes | Typical use |
|---|---|---|
| GET | In the URL query string | Read-only actions, searches, filters |
| POST | In the request body as form data | Creating or updating data, login, etc |
For this chapter, we focus on POST forms, because that is where request bodies and form data are most relevant.
Content-Type: How data is encoded
When you submit a POST form, the browser sets the Content-Type header and encodes the data accordingly.
Two important types for forms:
| Content-Type | Name / encoding | Typical use |
|---|---|---|
application/x-www-form-urlencoded | URL encoded key-value pairs | Most simple forms without files |
multipart/form-data | Multipart encoding with boundaries | Forms that include file uploads |
A backend must read form data according to the Content-Type header. If you parse form data as JSON or ignore the content type, you will get errors or empty data.
URL Encoded Form Data (`application/x-www-form-urlencoded`)
This is the default encoding when you submit a form without files.
Example form:
<form action="/register" method="post">
<input type="text" name="username">
<input type="email" name="email">
<input type="password" name="password">
<button type="submit">Register</button>
</form>The browser sends a request like:
POST /register HTTP/1.1
Content-Type: application/x-www-form-urlencoded
...
username=alice&email=alice%40example.com&password=secret123Rules:
- Each field is
name=value. - Pairs are joined with
&. - Special characters are percent-encoded, for example
@becomes%40, spaces often become+.
On the backend, almost every framework offers a way to parse this easily.
Example with FastAPI:
from fastapi import FastAPI, Form
app = FastAPI()
@app.post("/register")
async def register(
username: str = Form(...),
email: str = Form(...),
password: str = Form(...)
):
return {"username": username, "email": email}
Internally, FastAPI reads the application/x-www-form-urlencoded body and gives you the fields.
Multipart Form Data (`multipart/form-data`)
When your form includes file uploads, the browser uses multipart/form-data.
Example form:
<form action="/profile" method="post" enctype="multipart/form-data">
<input type="text" name="username">
<input type="file" name="avatar">
<button type="submit">Save</button>
</form>
Important detail: the enctype attribute must be multipart/form-data. Without it, the file will not be sent correctly.
The request might look like:
POST /profile HTTP/1.1
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryabc123
------WebKitFormBoundaryabc123
Content-Disposition: form-data; name="username"
alice
------WebKitFormBoundaryabc123
Content-Disposition: form-data; name="avatar"; filename="photo.png"
Content-Type: image/png
(binary data here)
------WebKitFormBoundaryabc123--The body is split into parts, each part has headers and a body.
On the backend, you typically get:
- Regular fields like
usernameas strings. - File fields like
avataras file-like objects or special file types.
A FastAPI style example:
from fastapi import FastAPI, Form, File, UploadFile
app = FastAPI()
@app.post("/profile")
async def update_profile(
username: str = Form(...),
avatar: UploadFile = File(...)
):
# avatar.filename, avatar.content_type, await avatar.read()
return {
"username": username,
"avatar_filename": avatar.filename,
}Even if you do not use FastAPI, the concept is the same: your framework parses multipart form bodies and gives you strings and files.
Common HTML Input Types and How They Are Sent
Text-like inputs
Inputs like text, email, password, hidden, etc:
<input type="text" name="name">
<input type="email" name="email">
<input type="password" name="password">
<input type="hidden" name="token" value="abc123">
These are sent as simple name=value pairs.
On the backend you usually read them as strings and then validate or convert them to other types.
Checkboxes
Checkbox behavior often surprises beginners.
<label>
<input type="checkbox" name="subscribe" value="yes">
Subscribe to newsletter
</label>Rules:
- If the checkbox is checked, the field is sent, like
subscribe=yes. - If it is not checked, the field is not sent at all.
Never assume a checkbox will always be present. If it is not checked, the backend might not receive the key at all. Always handle missing fields safely.
Multiple checkboxes with the same name:
<label><input type="checkbox" name="colors" value="red"> Red</label>
<label><input type="checkbox" name="colors" value="green"> Green</label>
<label><input type="checkbox" name="colors" value="blue"> Blue</label>If the user checks "red" and "blue", the browser sends:
colors=red&colors=blueYour backend might represent this as:
- A list:
["red", "blue"] - Or multiple values for the same key.
FastAPI example:
from typing import List
from fastapi import FastAPI, Form
app = FastAPI()
@app.post("/colors")
async def choose_colors(colors: List[str] = Form([])):
return {"selected": colors}
If no checkbox is selected, colors will be an empty list.
Radio buttons
Only one radio in a group can be selected.
<label><input type="radio" name="gender" value="male"> Male</label>
<label><input type="radio" name="gender" value="female"> Female</label>
<label><input type="radio" name="gender" value="other"> Other</label>If "female" is selected:
gender=femaleYour backend interprets this as a single string field.
Select (dropdown)
Single select:
<select name="country">
<option value="us">United States</option>
<option value="ca">Canada</option>
</select>Sent as:
country=usMulti select:
<select name="skills" multiple>
<option value="python">Python</option>
<option value="js">JavaScript</option>
<option value="sql">SQL</option>
</select>If user selects "Python" and "SQL":
skills=python&skills=sqlOn the backend, you usually handle it as a list of strings, same as multiple checkboxes.
Form Data vs JSON in Request Bodies
In a modern API, you will often see JSON request bodies. For example:
POST /api/users
Content-Type: application/json
{
"username": "alice",
"email": "alice@example.com"
}
However, browsers by default send form data from HTML forms, not JSON. Unless you use JavaScript to build and send your own JSON payload, simple <form> submissions use application/x-www-form-urlencoded or multipart/form-data.
Comparison:
| Aspect | Form Data | JSON |
|---|---|---|
Content-Type | application/x-www-form-urlencoded or multipart/form-data | application/json |
| Produced by | HTML forms (browser default) | JavaScript, API clients, mobile apps |
| Good for | Human filled forms, file uploads | APIs, structured data, nested objects |
| Nested data | Possible but messy (name conventions) | Natural (objects, arrays) |
If you build:
- A browser based application with HTML forms and no JavaScript, form data is natural and simple.
- A REST API for external clients, JSON request bodies are usually preferred.
You can support both, but your backend needs to parse them differently.
Nested and Complex Data in Forms
Forms are flat key-value pairs. There is no built-in object structure. To represent complex data, developers often use naming conventions.
Example, addresses with a flat naming convention:
<input type="text" name="address_street">
<input type="text" name="address_city">
<input type="text" name="address_zip">On the backend, you might group them:
address = {
"street": form["address_street"],
"city": form["address_city"],
"zip": form["address_zip"],
}Some frameworks support "bracket notation":
<input type="text" name="address[street]">
<input type="text" name="address[city]">
<input type="text" name="address[zip]">Sent as:
address[street]=Main+St&address[city]=SpringfieldThe framework might parse that into a nested object automatically. The exact behavior depends on the server framework or library.
For lists, sometimes you see:
<input type="text" name="tags[]">
<input type="text" name="tags[]">which can become:
tags[]=backend&tags[]=python
and the backend interprets tags as a list. This is a convention, not a browser rule.
Handling Form Data in a Backend (General Flow)
Regardless of language or framework, handling form data usually follows these steps:
- Read the request body according to
Content-Type. - Parse it into a data structure, usually:
- A dictionary of key to single value.
- Or a mapping of key to list of values.
- Convert and validate:
- Convert strings to integers, bools, dates, etc.
- Check required fields.
- Enforce length, format, allowed values.
- Use the data:
- Authenticate user.
- Create or update database records.
- Perform the action described by the form.
A minimal example with a low-level Python server (no framework) gives an idea of what happens under the hood:
from urllib.parse import parse_qs
def parse_form_body(body_bytes: bytes) -> dict:
body_str = body_bytes.decode("utf-8")
parsed = parse_qs(body_str)
# parse_qs gives lists, take first value for each key
return {key: values[0] for key, values in parsed.items()}In real projects, you will let your framework handle this, but understanding the raw steps helps you debug problems.
Common Pitfalls and Gotchas
Missing fields
Many input types can be absent from the form submission:
- Unchecked checkboxes.
- Unselected radio groups.
- Disabled inputs.
- Fields without a
nameattribute.
You should always handle missing fields safely, and never assume they are always present.
Incorrect `enctype` for file uploads
If you use <input type="file"> but forget enctype="multipart/form-data":
<form action="/upload" method="post">
<input type="file" name="avatar">
</form>The browser will not send the file correctly. The backend will not see the file data. Always set:
<form action="/upload" method="post" enctype="multipart/form-data">
...
</form>Mixed expectations: JSON vs form
If your backend expects JSON but the frontend sends form data, you might see:
- Empty body.
- Validation errors.
- Framework errors like "value is not a valid dict".
Similarly, if the backend expects form data but the client sends JSON, you will also get problems.
Always keep Content-Type and backend parsing in sync.
Large forms
Large text areas or many fields can produce a big request body. Some servers have limits on maximum request size. If the body is too large, the server might reject the request.
This is important for big comments, long blog posts, or complex multi-step forms.
When to Use Form Data in Backend Development
Form data is natural for:
- Traditional multi-page applications with server-rendered HTML and forms.
- Simple login and registration forms.
- Dashboard or admin panels where most interaction is form based.
- Handling file uploads from a browser.
Even if you build a modern single-page application, you will still work with form data when you:
- Integrate with third-party HTML forms.
- Support file uploads directly from a browser.
Understanding form data helps you:
- Debug incoming requests from browsers.
- Accept both traditional web forms and API requests.
- Decide when to use
multipart/form-dataversus JSON.
Practical End-to-End Example
Suppose you build a simple contact form.
1. HTML
<form action="/contact" method="post">
<input type="text" name="name" placeholder="Your name">
<input type="email" name="email" placeholder="Your email">
<textarea name="message" placeholder="Your message"></textarea>
<label>
<input type="checkbox" name="subscribe" value="yes">
Subscribe to newsletter
</label>
<button type="submit">Send</button>
</form>Data sent if user fills everything and checks subscribe:
name=Alice&email=alice%40example.com&message=Hello%21&subscribe=yesIf user does not check subscribe:
name=Alice&email=alice%40example.com&message=Hello%21
No subscribe field at all.
2. Backend handler (conceptual, FastAPI style)
from typing import Optional
from fastapi import FastAPI, Form
app = FastAPI()
@app.post("/contact")
async def handle_contact(
name: str = Form(...),
email: str = Form(...),
message: str = Form(...),
subscribe: Optional[str] = Form(None)
):
wants_subscription = subscribe == "yes"
# Save message, maybe send email, etc.
return {
"ok": True,
"name": name,
"email": email,
"subscribed": wants_subscription,
}
Key detail: subscribe might be None if the checkbox was not checked, so we treat that gracefully.
Understanding form data at this level will make it easier to work with HTML forms, debug submission issues, and design backends that correctly handle typical browser form submissions, including both simple key-value pairs and mixed data with file uploads.
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!