33.2. Building a Portfolio
Table of Contents
Why a Portfolio Matters for Backend Developers
A portfolio is concrete proof that you can build and ship working software. As a backend developer, you do not rely on visual design to impress people. Instead, you show:
- That you understand real problems.
- That you can design and implement robust APIs and data models.
- That you can deploy and maintain running systems.
Your portfolio is often more important than your formal education, especially for junior positions and self-taught developers.
A good backend portfolio is not a list of technologies.
It is a small set of real, running projects that solve clear problems and are easy to explore.
In this chapter you will learn how to plan, build, present, and grow such a portfolio.
What a Strong Backend Portfolio Includes
Think of your portfolio like a product. Your “users” are:
- Hiring managers
- Tech leads
- Other developers reviewing your GitHub
They want to quickly answer:
- Can this person write clean, maintainable backend code?
- Can they design APIs and data models?
- Can they work with databases, authentication, and deployment?
- Can they communicate their work clearly?
Your portfolio should provide evidence for each question:
| Question | Evidence in Portfolio |
|---|---|
| Can you write backend code? | Clear repositories, tests, clean structure, documentation |
| Can you work with databases and APIs? | Projects with real DB schema, REST APIs, queries, indexing |
| Can you handle auth, security, performance? | Auth & roles, validation, caching, pagination, logging |
| Can you deliver and maintain apps? | Deployed demos, CI/CD pipelines, Docker setups |
| Can you communicate? | README files, diagrams, short explanations of choices |
Choosing the Right Number and Type of Projects
You do not need many projects. You need a few good ones.
How many projects?
For a solid junior backend portfolio, aim for:
- 1 flagship project
Complex, well designed, deployed, and thoroughly documented. Ideally something full-featured like an e-commerce backend or multi-tenant app. - 2 to 3 supporting projects
Each focused on a different area, for example: - Task management / CRUD + auth
- Background jobs and email sending
- Real-time API or WebSocket based app
- Integration with a third-party API
More than 5 projects usually means each one is too shallow or poorly presented.
Types of projects that stand out
Choose projects that show core backend skills:
| Project Idea | What it Shows |
|---|---|
| Task Management API | CRUD, validation, auth, pagination, tests |
| E-commerce Backend | Complex relationships, payments, orders, inventory, caching |
| Authentication Service | Password hashing, JWT, refresh tokens, sessions |
| File Storage Service | S3 integration, presigned URLs, secure uploads/downloads |
| Analytics / Metrics Collector | Background processing, queueing, batch tasks |
| Real-time Chat API | WebSockets, message persistence, rate limiting |
You want coverage across data modeling, APIs, security, background tasks, and deployment.
Designing Portfolio Projects Intentionally
Do not just code randomly. Design each project to show specific skills.
Decide the “skills you want to prove”
Before writing code, write a short design note:
- Target: “I want this project to show that I can:”
- Design a REST API with good resource modeling.
- Handle authentication and authorization.
- Design and query a relational database.
- Write tests and set up CI.
- Deploy using Docker and a cloud host.
Then you map features to these skills:
| Skill | Design Decision Example |
|---|---|
| API design | Clean REST endpoints with versioning and pagination |
| Data modeling | Use relational DB, proper primary and foreign keys, indexes |
| Auth & permissions | JWT or session-based auth, roles, resource ownership checks |
| Background jobs | Queue for sending emails, generating reports, processing media |
| Deployability | Dockerfile, docker-compose, environment variables, logging |
Keep scope realistic, but non-trivial
A common mistake is to aim for something huge and never finish it.
Instead:
- Start with a Minimum Viable Version (MVV):
- Small set of features
- Clean architecture
- Good documentation
- Then iterate and improve in visible, well-documented steps.
Examples of scoped versions of an e-commerce backend:
| Version | Features Included |
|---|---|
| v0.1 | Users, products, simple cart, place order, no payments, local dev only |
| v0.2 | Basic auth, separated admin/user roles, simple SQL database, Dockerized |
| v0.3 | Stripe sandbox payments, background email notifications, deployed to a cloud host |
| v0.4 | Caching for product list, rate limiting, basic monitoring and logging |
Each version adds depth and demonstrates growth.
Making Projects Easy to Explore
Your projects must be easy to understand, run, and test.
A clear, friendly README
Every repository should have a README.md with:
- Short description
One paragraph: what this project is and what problem it solves. - Stack and features table
## Tech Stack
- Backend: Python, FastAPI
- Database: PostgreSQL
- Queue: Redis + RQ
- Auth: JWT (access + refresh)
- Containerization: Docker, Docker Compose
| Area | Features |
|------------|--------------------------------------------------------|
| API | REST, pagination, filtering, validation |
| Security | Hashed passwords, JWT, role-based access |
| Database | Migrations, indexes, foreign keys, constraints |
| DevOps | Dockerfile, docker-compose, basic CI pipeline |
| Testing | pytest, coverage for core endpoints and services |
- How to run locally
Example:
# 1. Clone repository
git clone https://github.com/yourname/task-api.git
cd task-api
# 2. Copy environment template
cp .env.example .env
# 3. Start with Docker
docker compose up --build
# 4. Open API docs
# Visit http://localhost:8000/docs- API overview
A short table of main endpoints:
| Method | Path | Description |
|--------|-----------------------|-----------------------------|
| POST | /auth/register | Create user account |
| POST | /auth/login | Obtain access / refresh |
| GET | /tasks | List tasks (paginated) |
| POST | /tasks | Create a task |
| PATCH | /tasks/{task_id} | Update task |
| DELETE | /tasks/{task_id} | Delete task (owner only) |
- Architecture summary
Briefly describe structure:
- `app/`
- `api/` FastAPI routes
- `core/` configuration, security, dependencies
- `models/` SQLAlchemy models
- `schemas/` Pydantic schemas
- `services/` business logic
- `tests/` unit and integration tests- Screenshots or diagrams (for APIs, screenshots of docs or Postman)
Consistent project structure
Use a clean, recognizable layout. For example, for FastAPI:
app/
api/
core/
models/
schemas/
services/
db.py
tests/
Dockerfile
docker-compose.yml
README.md
pyproject.toml or requirements.txt
.env.exampleConsistency between projects makes you look professional and organized.
Using Git and GitHub Effectively
Your Git history and GitHub profile tell a story about how you work.
Clean commit history
Avoid giant commits like “stuff” or “fixes.” Use small, descriptive commits:
feat(auth): add JWT login endpointfix(tasks): validate due date is in the futuretest(users): add registration API testschore(ci): add GitHub Actions workflow for tests
You can group work logically, for example:
- Add new feature in one or several
featcommits. - Fix small issues with
fixcommits. - Adjust docs with
docscommits.
Branches and pull requests
Even for your own projects, you can:
- Create feature branches:
feature/add-task-search. - Open pull requests into
mainordevelop. - Write a short PR description, for example:
## Summary
- Added text search endpoint for tasks
- Indexed `title` and `description` fields in PostgreSQL
- Updated OpenAPI docs and tests
## Notes
- Uses `ILIKE` for case-insensitive search
- Added limit to results to avoid heavy queriesThis shows that you understand collaborative workflows.
GitHub profile hygiene
- Pin 3 to 6 of your best repositories.
- Add a short GitHub profile README that:
- Says you focus on backend development.
- Links to your portfolio site or main project.
- Lists main technologies you use.
- Archive or hide messy, very early experiments, or clearly label them as “playground” projects.
Demonstrating Backend Skills Explicitly
You are a backend developer. Make that obvious.
Skills to highlight inside projects
Try to show at least some of these across your portfolio:
| Area | Examples to Implement |
|---|---|
| API design | REST endpoints, versioning, pagination, filtering, sorting |
| Database design | Proper schemas, indexes, foreign keys, migrations |
| Authentication | Login, registration, password hashing, token based auth |
| Authorization | Roles, permissions, resource ownership checks |
| Validation | Robust input validation, clear error responses |
| Testing | Unit tests, integration tests, API tests |
| Background processing | Queued jobs, email sending, long running tasks |
| Caching | Redis caching for heavy queries or responses |
| Logging & monitoring | Structured logs, health checks, basic metrics |
| Deployment | Docker, CI pipeline, deployment scripts or guides |
You do not need all of these in every project, but your portfolio as a whole should cover them.
Show good security habits
Even small personal projects should:
- Hash passwords with a strong algorithm.
- Never store secrets in code.
- Validate and sanitize inputs.
- Return appropriate HTTP status codes.
- Avoid revealing internal details in error messages.
Mention these explicitly in README files, for example:
## Security
- Passwords hashed using Argon2
- JWT tokens signed using HS256, secret stored in environment variables
- Rate limiting on login endpoint
- Validation of all incoming data using Pydantic modelsMaking Projects Deployable and Live
A running demo is powerful proof that you can ship.
Minimal deployability
At least your flagship project should have:
- A
Dockerfileanddocker-compose.yml. - A clear deployment section in the README:
- How to build the image.
- Required environment variables.
- Example
docker runordocker composecommands.
For example:
docker build -t yourname/task-api .
docker run -p 8000:8000 --env-file .env yourname/task-apiLive demos (if affordable and safe)
If you can, deploy to a cloud platform. For example:
- Backend API on a small VPS or platform (Render, Fly.io, Railway, etc.).
- PostgreSQL as a managed service or small container.
- Redis for caching and background tasks.
Add:
- Base URL in the README, for example:
https://api.example.com. - Link to OpenAPI / Swagger docs.
- Test/demo credentials if appropriate (for non sensitive environments).
Never expose real secrets in a public demo:
- Use demo accounts and fake data.
- Keep
.envfiles out of Git. - Use environment variables for tokens and passwords.
Presenting Your Portfolio on a Website or Profile
You do not need a fancy frontend, but you do need a clear entry point.
Simple portfolio site
You can use:
- A static site generator.
- A very simple frontend.
- Or even a GitHub profile README as a “home page.”
For each project, provide:
- Title.
- 2 or 3 line description.
- Tech stack.
- Links:
- GitHub repository.
- Live API or demo (if available).
- API docs link.
- Short bullet list of “What this shows”:
**What this demonstrates**
- REST API design with FastAPI
- JWT based auth (access + refresh)
- PostgreSQL schema with indexes and foreign keys
- Background jobs with Redis Queue
- Dockerized deployment and CI with GitHub ActionsTarget your audience
If you are applying for backend roles, emphasize:
- Backends and infrastructure projects first.
- Data modeling, performance, scalability.
- Security and testing.
Do not hide backend behind flashy UI. Frontend is optional, not required.
Writing About Your Work
Being able to explain your decisions is a valuable skill.
Short case studies
For your flagship project, consider writing a short “case study” page or section:
- Problem: what is the app for?
- Constraints: what assumptions you made.
- Architecture: diagrams of main components.
- Key decisions and why you chose them:
- Why FastAPI instead of another framework.
- Why PostgreSQL and not NoSQL.
- How you modeled certain relationships.
- Challenges and how you solved them.
Example structure:
## Architecture Overview
This service is built as a monolithic FastAPI application with a PostgreSQL database.
A separate worker process consumes Redis-backed queues for background tasks such as:
- Sending email notifications
- Generating PDF invoices
- Cleaning up old data
The API is deployed with Docker and served via Uvicorn behind an Nginx reverse proxy.These explanations help interviewers ask good questions and see how you think.
Updating and Maintaining Your Portfolio
Your portfolio is not static. It should grow as you grow.
Keep it curated
Every few months:
- Review your projects.
- Archive ones that no longer represent your current skills.
- Improve documentation and tests for the ones you keep.
Show progression
It is good to have older, simpler projects next to newer, more complex ones.
You can emphasize the learning journey:
- “My first REST API, now archived, but kept to show progress.”
- “Second version of my Task API, with auth and tests added.”
This shows that you can learn and improve over time.
Common Mistakes to Avoid
Avoid these pitfalls that weaken backend portfolios:
| Mistake | Why It Is a Problem |
|---|---|
| Only frontend or toy scripts | Does not show backend architecture or data modeling |
| No README or documentation | Hard to understand, looks unprofessional |
| Cannot run the project locally | Suggests poor understanding of environments and dependencies |
| No tests at all | Red flag for maintainability and quality mindset |
| Hard coded secrets in code | Serious security concern |
| Forked projects without real contributions | Does not prove you can build or maintain systems |
| Overuse of tutorial code without changes | Shows you can follow tutorials, not solve new problems |
If you followed a tutorial, that is fine, but:
- Clearly state it.
- Explain what you built on top.
- Show your own improvements or extensions.
A Practical Action Plan
You can follow this concrete sequence to build your portfolio from scratch.
Step 1: Core learning
Use the rest of this course to learn:
- Python backend development with FastAPI.
- SQL and PostgreSQL.
- Authentication and authorization basics.
- Docker and simple deployment.
Step 2: Build 2 small focused projects
Examples:
- Task Management API
- CRUD tasks, user accounts.
- JWT auth.
- Pagination and filtering.
- Basic tests.
- Local Docker setup.
- Authentication and User Service
- Registration, login, password reset flow.
- Email verification with a background worker.
- Security best practices.
Each project gets a clean README and consistent structure.
Step 3: Build 1 flagship project
For example, an e-commerce backend:
- Products, categories, inventory.
- Shopping cart and orders.
- Payments integration in sandbox mode.
- Admin endpoints.
- Background jobs (emails, reports).
- Caching for some views.
- Docker and minimal CI.
- Optional: deployed demo.
Step 4: Polish presentation
- Improve README files, add diagrams.
- Clean up Git history and branches.
- Pin repositories on GitHub.
- Create a small portfolio page linking everything.
Step 5: Keep improving
- Add tests and metrics where missing.
- Improve performance for one feature and document it.
- Try new tools, for example Redis, Celery, or message queues, in small side projects.
Summary
A strong backend portfolio:
- Focuses on a few well executed projects, not many unfinished ones.
- Demonstrates real backend skills: APIs, databases, auth, security, testing, deployment.
- Is easy to explore, with clean code, clear structure, and good documentation.
- Shows your ability to ship and maintain working systems.
- Evolves over time to reflect your current capabilities.
If you follow the action plan in this chapter, by the time you finish this course you will not only understand backend development, you will also have a concrete portfolio that proves it.
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!