5.6. Functions and Type Hints
Table of Contents
Why Functions Matter in Backend Python
In backend development you will write functions all the time. Functions let you:
- Group related logic in one place
- Reuse code instead of copying and pasting
- Give names to operations so your code reads like documentation
- Test small pieces of behavior independently
As a backend developer you also want functions to be easy to understand and safe to use. That is where type hints help. Together, functions and type hints are one of your main tools for writing clear and reliable backend code.
In this chapter you will focus on:
- How to define and use functions in Python
- Different kinds of function parameters
- Return values
- How to add type hints to parameters and return values
- How to type common backend data structures
- How type checking fits into real backend projects
Defining and Calling Functions
A function in Python is created with the def keyword.
def greet():
print("Hello from the backend!")You call (or invoke) the function by using its name followed by parentheses:
greet() # prints: Hello from the backend!This is a function with:
- No parameters
- No explicit return value
Parameters and Arguments
Most backend functions need input. You declare inputs as parameters. When you call the function, you pass arguments.
def greet_user(name):
print(f"Hello, {name}!")
greet_user("Alice") # "Alice" is the argument
greet_user("Bob")Here:
nameis the parameter"Alice"and"Bob"are arguments
You can define multiple parameters:
def create_user(username, email):
print(f"Creating user {username} with email {email}")
create_user("alice", "alice@example.com")Return Values
Functions can send a value back to the caller using return.
def add(a, b):
result = a + b
return result
sum_value = add(3, 5) # sum_value is 8
If you do not use return, or you use return without a value, Python returns None:
def log_message(message):
print(f"[LOG] {message}")
value = log_message("Server started")
print(value) # prints: NoneYou can return any type:
def is_adult(age):
return age >= 18 # bool
def get_default_port():
return 8000 # int
def get_default_headers():
return {"Content-Type": "application/json"} # dictDefault Parameter Values
You can give parameters default values. These are used when the caller does not pass a value.
def send_email(to_address, subject, body="", is_html=False):
print(f"Sending email to {to_address}")
print(f"Subject: {subject}")
print(f"HTML? {is_html}")
print(f"Body: {body}")Examples of calling:
send_email("user@example.com", "Welcome")
send_email(
"user@example.com",
"Weekly report",
body="Here is your report...",
)
send_email(
"user@example.com",
"Password reset",
body="<p>Click the link</p>",
is_html=True,
)Order rule: parameters must follow this order:
- Required parameters (no default)
- Parameters with default values
Rule: In Python function definitions, all parameters without default values must come before any parameters with default values.
For example, def f(a, b=1) is valid, but def f(a=1, b) is an error.
Keyword Arguments
You can call functions using keyword arguments, where you specify parameter_name=value:
def connect_db(host, port, user, password):
...
connect_db(
host="localhost",
port=5432,
user="app_user",
password="secret",
)You can change the order when you use keywords:
connect_db(
password="secret",
user="app_user",
port=5432,
host="localhost",
)In backend code keyword arguments often make calls clearer, especially when many arguments are the same type, like several strings or numbers.
Variable-Length Arguments: *args and **kwargs
Sometimes you do not know how many arguments a function may receive. Python has two special patterns:
*args: Extra Positional Arguments
*args collects extra positional arguments into a tuple.
def log_all(*messages):
for message in messages:
print("[LOG]", message)
log_all("Server started")
log_all("DB connected", "Cache ready", "Worker started")Here:
messagesis a tuple of all positional arguments.
**kwargs: Extra Keyword Arguments
**kwargs collects extra keyword arguments into a dictionary.
def log_event(event_name, **data):
print(f"Event: {event_name}")
for key, value in data.items():
print(f" {key} = {value}")
log_event(
"user_login",
user_id=123,
ip="192.168.0.1",
country="US",
)Here:
datais adictwith all keyword arguments.
These patterns are very common in backend libraries, for example in logging, configuration, or database query helpers.
Return Early and Guard Clauses
Backend functions often need to validate input and stop early if something is wrong.
def normalize_page(page):
if page < 1:
return 1
return pageThis is called a guard clause. It keeps functions short and clear.
Another example:
def get_first_or_none(items):
if not items:
return None
return items[0]Why Type Hints Matter for Backend Code
Python is dynamically typed, so the interpreter does not require you to specify types. You can write:
def add(a, b):
return a + bThis works, but:
- You cannot see at a glance what types
aandbshould be - Your editor cannot catch type mistakes before you run the code
- Big backend projects become harder to understand
Type hints solve this. They are optional hints that describe the expected types.
Type hints are checked by tools such as mypy or pyright, not by Python at runtime.
Basic Type Hints for Function Parameters
You add type hints after a colon :.
def add(a: int, b: int):
return a + bThis means:
ashould be anintbshould be anint
Python still allows other types at runtime, but type checkers and IDEs will warn you.
Some basic built-in types you will use:
| Type | Example value | Where used in backend |
|---|---|---|
int | 200, 404, 8080 | Status codes, ports, IDs, counts |
float | 3.14, 0.5 | Prices, percentages, time intervals |
str | "GET", "application/json" | HTTP methods, headers, messages |
bool | True, False | Flags like is_active, is_admin |
bytes | b"raw data" | Binary files, network data |
Example with parameters:
def send_response(status_code: int, body: str) -> None:
print(f"Status: {status_code}")
print("Body:", body)Type Hints for Return Values
You annotate the return type with -> after the parameter list.
def add(a: int, b: int) -> int:
return a + b
If a function returns nothing useful, use -> None:
def log_error(message: str) -> None:
print(f"[ERROR] {message}")If a function returns different types in different branches, you should try to make it consistent. If that is not possible, you will use unions, which you will see later.
Rule: Every non trivial function in backend code should have an explicit return type hint.
For example, use -> int, -> str, -> dict, or -> None, instead of leaving it unannotated.
Using Type Hints with Default Values
Default values work together with type hints:
def paginate(page: int = 1, page_size: int = 20) -> None:
print(f"Page {page}, size {page_size}")You still specify the type, even if a default value is present. The default must match the type.
Typing Common Data Structures
Backend code uses collections all the time. You will use the typing module.
In Python 3.9 or newer, you can write:
from typing import Dict, List, Tuple, Set
or use built-in generics like list[int]. Both styles are common. Here you will show both, then focus on the newer style.
Lists
A list of integers:
from typing import List
def sum_scores(scores: List[int]) -> int:
return sum(scores)Newer syntax:
def sum_scores(scores: list[int]) -> int:
return sum(scores)Dictionaries
A dictionary from str to int, for example a mapping of status code names to numbers:
from typing import Dict
def get_status_codes() -> Dict[str, int]:
return {"ok": 200, "not_found": 404}Newer syntax:
def get_status_codes() -> dict[str, int]:
return {"ok": 200, "not_found": 404}Tuples
A tuple with a fixed shape such as (host, port):
from typing import Tuple
def get_default_db_address() -> Tuple[str, int]:
return ("localhost", 5432)Newer syntax:
def get_default_db_address() -> tuple[str, int]:
return ("localhost", 5432)Optional and None
Many backend functions can return "no result" instead of a value. Type hints should represent that.
You use Optional[T] or T | None.
from typing import Optional
def find_user_email(user_id: int) -> Optional[str]:
# None means not found
if user_id == 1:
return "admin@example.com"
return NoneIn newer syntax:
def find_user_email(user_id: int) -> str | None:
if user_id == 1:
return "admin@example.com"
return None
To annotate a parameter that can be None:
def send_welcome_email(email: str | None) -> None:
if email is None:
print("No email to send welcome message to.")
return
print(f"Sending welcome email to {email}")Unions: One of Several Types
Sometimes a function can accept or return one of several types.
You can write Union[A, B] or A | B.
from typing import Union
def parse_user_id(raw: Union[int, str]) -> int:
if isinstance(raw, int):
return raw
return int(raw)Newer syntax:
def parse_user_id(raw: int | str) -> int:
if isinstance(raw, int):
return raw
return int(raw)Typing *args and **kwargs
You can give types to variable-length arguments too.
Typed *args
from typing import Any
def log_many(*messages: str) -> None:
for msg in messages:
print("[LOG]", msg)
This says: every positional argument must be a str.
Typed **kwargs
def build_filters(**filters: str) -> dict[str, str]:
# filters might be: status="active", role="admin"
return filtersThis says:
- Every keyword value must be a
str - The function returns a
dict[str, str]
Callable Types
Sometimes you pass one function into another, for example a callback.
You can use Callable to type this.
from typing import Callable
def run_query_with_logger(query: str, logger: Callable[[str], None]) -> None:
logger(f"Running query: {query}")
# execute query here
logger("Query finished")Callable[[str], None]means a function that takes astrand returnsNone.
You can use it like this:
def simple_logger(message: str) -> None:
print("[DB]", message)
run_query_with_logger("SELECT 1", simple_logger)Type Aliases for Better Readability
If a type is long or used many times, you can give it a name.
from typing import Dict, Any
JSON = Dict[str, Any]
def parse_request_body(body: bytes) -> JSON:
# pretend to parse JSON
return {"raw": body.decode("utf-8")}Newer syntax:
from typing import Any
JSON = dict[str, Any]
def parse_request_body(body: bytes) -> JSON:
return {"raw": body.decode("utf-8")}This makes function signatures easier to read, especially in backend code where you often deal with JSON-like structures.
Practical Backend Examples with Type Hints
Here are some realistic small backend-style functions with type hints.
Parsing Query Parameters
def parse_int_param(raw: str | None, default: int = 0) -> int:
if raw is None:
return default
try:
return int(raw)
except ValueError:
return defaultUsage:
page_str = "5" # pretend from query string
page = parse_int_param(page_str, default=1) # page is intBuilding an HTTP Response Object
from typing import Any
Headers = dict[str, str]
Body = dict[str, Any]
def make_json_response(
data: Body,
status_code: int = 200,
headers: Headers | None = None,
) -> dict[str, Any]:
if headers is None:
headers = {}
headers.setdefault("Content-Type", "application/json")
return {
"status_code": status_code,
"headers": headers,
"body": data,
}Finding a User
from typing import TypedDict, Optional
class User(TypedDict):
id: int
username: str
email: str
def get_user_by_id(user_id: int) -> Optional[User]:
if user_id == 1:
return {
"id": 1,
"username": "admin",
"email": "admin@example.com",
}
return None
Here User is a typed dictionary. You will learn more about structured models later, but this gives you a feel for how type hints describe real backend data.
Type Checking and Tooling
Type hints alone do nothing at runtime. To benefit from them you use tools:
- mypy: static type checker for Python
- pyright: type checker and language server
- IDEs like VS Code and PyCharm can use type hints to:
- Show better autocompletion
- Highlight type errors while you type
- Help navigate code in big backend projects
A typical workflow:
- Add type hints to your functions
- Run
mypyin your project - Fix reported issues
- Repeat
You do not need to be perfect. Even partial type coverage is very useful in real backend projects.
Common Pitfalls with Functions and Type Hints
Mutable Default Arguments
Never use a mutable object as a default value.
Bad:
def add_header(headers: dict[str, str] = {}): # bad
headers["X-App"] = "my-app"
return headersThis dictionary is shared between calls.
Correct:
from typing import Optional
def add_header(headers: Optional[dict[str, str]] = None) -> dict[str, str]:
if headers is None:
headers = {}
headers["X-App"] = "my-app"
return headers
Type hints help you see that headers can be None.
Inconsistent Return Types
Avoid functions that sometimes return one type and sometimes another unrelated type.
Bad:
def get_user_maybe(user_id: int):
if user_id == 1:
return {"id": 1}
return FalseBetter:
from typing import Optional
def get_user_maybe(user_id: int) -> Optional[dict[str, int]]:
if user_id == 1:
return {"id": 1}
return NoneSummary
In this chapter you learned:
- How to define functions with parameters, default values, and return values
- How to use
argsand*kwargsfor flexible APIs - How to add type hints to function parameters and return values
- How to type collections like
list,dict, andtuple - How to use
Optional, unions,Callable, and type aliases - How type hints make backend Python code clearer, safer, and easier to maintain
You now have the tools to write clear, typed functions in Python, which is the foundation for building reliable backend services.
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!