4.13. Clean Code Principles
Table of Contents
Why Clean Code Matters
Clean code is code that is easy to read, easy to understand, and easy to change. You are not only writing for the computer, you are writing for future humans, including your future self.
Imagine opening your own code 6 months later and having no idea what it does. Clean code prevents that.
Goal of clean code:
Write code that is easy to understand and safe to change.
In this chapter you will see simple but powerful habits you can use from your very first programs, no matter which language you use.
We will use Python-style pseudocode for examples, but the ideas apply to any language.
Meaningful Names
Names are the first thing people see in your code. Good names make code almost read like plain English.
Use descriptive variable and function names
Bad:
def c(a, b):
return a * b * 3.14
What is c? What are a and b?
Better:
def circle_area(radius):
return radius * radius * 3.14Now the name explains what the function does and what the parameter is.
More examples:
| Bad name | Better name | Why it is better |
|---|---|---|
x | user_age | Tells you what the value represents |
n | max_retries | Shows meaning and intent |
p | product_price | Clear business meaning |
f | read_file_content | Verb + object explains the action |
d | user_by_id | Suggests it is a mapping of id to user |
Rule: Prefer clear, longer names over short and confusing names.
If a name saves you one second to type, but costs 10 seconds every time you read it, it is a bad trade.
Use consistent naming style
Within a project, use the same style everywhere.
Common styles:
| Style | Example | Often used for |
|---|---|---|
snake_case | user_profile | Python variables, functions |
camelCase | userProfile | JavaScript variables, functions |
PascalCase | UserProfile | Classes, types |
SCREAMING_SNAKE_CASE | MAX_SIZE | Constants |
Pick the style that your language community uses and stick to it.
Bad:
userName = "Alice"
user_age = 30
UserCountry = "FR"Better:
user_name = "Alice"
user_age = 30
user_country = "FR"Avoid meaningless prefixes and comments in names
Bad:
data1 = "Alice"
data2 = 30
data3 = "FR"Better:
user_name = "Alice"
user_age = 30
user_country = "FR"Do not encode too much in the name with weird prefixes:
Bad:
strUserNm = "Alice"
intUserId = 123Your type system and IDE can already tell you types.
Make Booleans read like questions
Boolean variables and functions should sound like yes/no questions.
Bad:
flag = True
if flag:
...Better:
is_active = True
if is_active:
...Bad:
def password(user):
...Better:
def is_valid_password(user):
...Small, Focused Functions
A function should do one thing, and do it well. If you cannot describe what a function does in a short sentence, it probably does too much.
One responsibility per function
Bad:
def process_order(order):
# 1. validate order
if not order.items:
raise ValueError("No items")
# 2. calculate total
total = 0
for item in order.items:
total += item.price * item.quantity
# 3. save to database
db.save(order, total)
# 4. send email
send_email(order.user.email, "Order received", "Thanks!")This function validates, calculates, saves, and sends email. Too many responsibilities.
Better:
def validate_order(order):
if not order.items:
raise ValueError("No items")
def calculate_order_total(order):
total = 0
for item in order.items:
total += item.price * item.quantity
return total
def save_order(order, total):
db.save(order, total)
def notify_order_received(order):
send_email(order.user.email, "Order received", "Thanks!")
def process_order(order):
validate_order(order)
total = calculate_order_total(order)
save_order(order, total)
notify_order_received(order)
Now each function has a clear purpose, and process_order reads like a story.
Rule: If you can split a function into smaller functions with clear names, you probably should.
Keep functions short
There is no strict line, but many developers try to keep functions short enough to see fully on one screen, for example 10 to 30 lines.
Compare:
Bad:
def handle_user_request(request):
# 100 lines doing many things
...Better:
def handle_user_request(request):
user = authenticate(request)
validate_request(request)
data = parse_data(request)
result = execute_action(user, data)
return build_response(result)Each called function will be shorter and focused.
Avoid too many parameters
If a function has many arguments, it is harder to call correctly and to understand.
Bad:
def create_user(name, age, country, email, is_admin, is_active, created_at, updated_at):
...Better, group related data into an object or dictionary:
def create_user(user_data):
...Or at least use keyword arguments when calling:
create_user(
name="Alice",
age=30,
country="FR",
email="a@example.com",
is_admin=False,
is_active=True,
created_at=now(),
updated_at=now(),
)Comments That Add Value
Comments should explain why something is done, not repeat what is obvious from the code.
Avoid explaining the obvious
Bad:
# increase i by 1
i = i + 1The code already says that.
Better:
# move to the next page
current_page = current_page + 1Now the comment adds context.
Use comments to explain intent, not to fix bad code
Bad:
# this function validates user input and saves it to the database and sends an email
def handle_user():
...The real problem is the function does too many things. Fix the code instead:
def validate_user_input(...):
...
def save_user(...):
...
def send_welcome_email(...):
...
def handle_user():
...Now you do not need that long comment.
Document reasons, not just behavior
Good uses of comments:
- Explain why a non-obvious choice was made
- Explain why something that looks wrong is actually correct
- Warn about performance or security implications
Example:
# We use a fixed seed here so that tests are repeatable
random.seed(42)# This query intentionally does not use an index because we need the latest dataKeep comments up to date
Old comments that are no longer true are dangerous.
Bad:
# This function returns user age
def get_user_data():
return {"name": "Alice", "age": 30, "country": "FR"}If behavior changes and comment is not updated, readers are misled.
Rule: If you change code, update or remove related comments.
Consistent Formatting and Style
Formatting is not about the computer. It is for human eyes. Consistent style makes code easier to scan and read.
Indentation and spacing
Use consistent indentation, usually 2 or 4 spaces. Do not mix tabs and spaces.
Bad:
if is_valid:
print("OK")
print("Still valid")Better:
if is_valid:
print("OK")
print("Still valid")Use spaces around operators:
Bad:
total=price*quantity+taxBetter:
total = price * quantity + taxBreak long lines
Very long lines are hard to read and to see in many editors.
Bad:
send_email(user.email, "Welcome to our very cool application", "Hello " + user.name + ", thanks for registering. Please click this very long link to verify your account: " + verification_link)Better:
subject = "Welcome to our very cool application"
body = (
"Hello " + user.name +
", thanks for registering. Please click this link to verify your account: " +
verification_link
)
send_email(user.email, subject, body)Use blank lines to group logic
Blank lines help structure code visually.
Bad:
def process():
user = get_user()
if not user:
return None
data = load_data()
result = compute(user, data)
save_result(result)
return resultBetter:
def process():
user = get_user()
if not user:
return None
data = load_data()
result = compute(user, data)
save_result(result)
return resultAvoiding Repetition (DRY)
DRY stands for "Don't Repeat Yourself". Repeated code is harder to maintain, because you must change it in many places.
Extract repeated code into functions
Bad:
def send_welcome_email(user):
body = "Hello " + user.name + ", welcome!"
send_email(user.email, "Welcome", body)
def send_password_reset_email(user, token):
body = "Hello " + user.name + ", reset your password: " + token
send_email(user.email, "Reset password", body)Both build email bodies in similar ways.
Better:
def build_greeting(user):
return "Hello " + user.name + ", "
def send_welcome_email(user):
body = build_greeting(user) + "welcome!"
send_email(user.email, "Welcome", body)
def send_password_reset_email(user, token):
body = build_greeting(user) + "reset your password: " + token
send_email(user.email, "Reset password", body)Now if you want to change the greeting, you change one place.
Avoid copy-paste logic
Suppose you validate email in two places:
Bad:
def register_user(email):
if "@" not in email or "." not in email:
raise ValueError("Invalid email")
...
def update_email(user, new_email):
if "@" not in new_email or "." not in new_email:
raise ValueError("Invalid email")
...Better:
def validate_email(email):
if "@" not in email or "." not in email:
raise ValueError("Invalid email")
def register_user(email):
validate_email(email)
...
def update_email(user, new_email):
validate_email(new_email)
...Simplicity Over Cleverness
Simple code is usually better than "smart" code that is hard to understand.
Prefer clear loops over complex one-liners
Many languages let you write very short but dense statements. Use them carefully.
Compare:
# Complex one-liner
result = [x * 2 for x in numbers if x % 2 == 0]This is fine if you know the syntax, but for a beginner it might be confusing.
You can write:
result = []
for number in numbers:
if number % 2 == 0:
result.append(number * 2)Both are correct. Use the simpler form if your team is new, or if the logic is more complex.
Avoid unnecessary clever tricks
Bad:
# Using a hacky trick to convert boolean to int
value = True + True + False # 2Better:
value = int(True) + int(True) + int(False)Or simply count with clear logic.
Do not prematurely optimize
Do not try to make code "extremely fast" before you know where the real performance problem is.
Bad:
# Very complex code to avoid a tiny extra loopBetter:
- First write simple, clear code.
- Measure performance.
- Optimize only the parts that are proven slow.
Rule: Make it work, then make it clear, then, if needed, make it fast.
Defensive Programming and Error Handling Style
Clean code is also about how you handle incorrect data and unexpected situations.
(You will see full error handling techniques in a dedicated chapter, here we focus on style.)
Fail fast and clearly
When inputs are invalid, handle it early.
Bad:
def divide(a, b):
return a / b # May crash later if b is 0Better:
def divide(a, b):
if b == 0:
raise ValueError("b must not be zero")
return a / bNow the error is clear and close to the cause.
Avoid deeply nested code
Deep nesting makes code hard to read.
Bad:
def process(user):
if user is not None:
if user.is_active:
if has_permission(user):
do_something()Better, use early returns:
def process(user):
if user is None:
return
if not user.is_active:
return
if not has_permission(user):
return
do_something()Writing Simple Tests Early
Testing has its own chapter, but as a clean code habit you should think about tests as you write code.
Functions that are easy to test are usually clean
Pure functions, that take inputs and return outputs without hidden effects, are easier to test and easier to reason about.
Example of a pure function:
def calculate_total(price, quantity, tax_rate):
return price * quantity * (1 + tax_rate)This is easy to test:
assert calculate_total(10, 2, 0.1) == 22If a function reads global variables, writes files, prints to console, and returns a value, it becomes much harder to test and understand.
So by designing functions that are easy to test, you also improve cleanliness.
Clean Code in Small Programs vs Large Systems
As a beginner you might wonder if clean code is only for large applications. It is not.
Small scripts
Even a 20-line script benefits from:
- Descriptive names
- A few small functions
- Simple comments
Example:
Bad:
import sys
f = open(sys.argv[1])
c = f.read().split("\n")
for l in c:
if l != "":
print(l)Better:
import sys
def read_lines(file_path):
with open(file_path) as f:
return f.read().splitlines()
def print_non_empty_lines(lines):
for line in lines:
if line:
print(line)
def main():
file_path = sys.argv[1]
lines = read_lines(file_path)
print_non_empty_lines(lines)
if __name__ == "__main__":
main()Even though it is longer, it is much clearer.
Large backend applications
When your project grows, these small habits become essential:
- A bad name might appear in dozens of files.
- A badly structured function might be impossible to modify safely.
- Duplicated logic might cause bugs when you fix one copy but forget another.
Clean code scales better.
Practicing Clean Code
Clean code is not something you learn once. It is a habit you build.
Simple practice ideas
- After writing a function, read it out loud as if explaining to a friend. Does it sound simple?
- Rename any variable that makes you pause to remember what it is.
- Before adding a comment, ask "Can I make the code itself clearer instead?"
- Look for copy-pasted code and try to extract it into a function.
- When you review your own code, focus on making it easier to understand, not just on "Does it work?"
A small refactoring exercise
Start with this messy code:
def handle(u, a):
if a > 18:
print("ok")
print("welcome " + u)
else:
print("no")Try to turn it into cleaner code:
Possible version:
ADULT_AGE = 18
def is_adult(age):
return age >= ADULT_AGE
def greet_user(name):
print("welcome " + name)
def handle_user(name, age):
if not is_adult(age):
print("Access denied")
return
print("Access granted")
greet_user(name)Now the code explains itself.
Summary
Key ideas from this chapter:
- Use meaningful, consistent names that describe purpose.
- Keep functions small, focused, and with a single responsibility.
- Write comments that explain why, not what is obvious.
- Format code consistently with clear indentation and spacing.
- Avoid repetition by extracting common logic into functions.
- Prefer simple, clear code over clever tricks.
- Handle errors early and reduce deep nesting.
- Design functions that are easy to test.
Clean code principle: Code is read far more often than it is written.
Always optimize for the reader.
These habits will make all later backend topics, such as web frameworks, databases, and APIs, easier to understand and safer to implement.
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!