3.11. Basic Git Workflow
Table of Contents
Overview
In this chapter you will learn how to use Git in your daily work as a backend developer. You already know what Git is and how to install it from previous chapters. Here, we focus on the typical workflow you will repeat in almost every project.
We will walk step by step from cloning a repository to making changes, committing, pushing, pulling, and handling simple conflicts, with many concrete command examples.
The Life Cycle of a Change
A basic Git workflow for a backend project usually follows this pattern:
- Get the code on your machine:
git clonefor a new project- or
git pullto update an existing local copy - Create a new branch for your work:
git checkout -b feature/...- Work on files:
- edit, add, delete, move
- See what changed:
git statusgit diff- Stage the changes you want to keep:
git add ...- Commit with a clear message:
git commit -m "..."- Push your branch to the remote:
git push origin your-branch- Open a Pull Request / Merge Request on GitHub / GitLab
- After review, merge to main branch
- Update your local main / master:
git checkout maingit pull origin main
We will now go through each step in detail with examples.
Cloning a Repository
To work on a project that already exists on GitHub or GitLab, you clone it.
Example: Cloning from GitHub
Imagine you have a repository at:
https://github.com/example-user/todo-api.git
Open a terminal in the directory where you want the project folder:
git clone https://github.com/example-user/todo-api.git
Git will create a new directory todo-api and download the full history.
Move into the project folder:
cd todo-apiCheck which branch you are on:
git branchExample output:
* main
This means your current branch is main.
Cloning with SSH
If you set up SSH keys, you might clone with SSH instead of HTTPS:
git clone git@github.com:example-user/todo-api.git
For everyday workflow, cloning is done once per machine. After that you usually work with git pull and branches.
Checking Repository Status
Before and after changes, you should know what is going on in your repository. The main tool is:
git statusExample Scenario
You just cloned the project:
git statusOutput:
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree cleanThis means:
- You are on branch
main - Your local
mainis the same asorigin/main(the remote version) - There are no local changes
Now edit a file, for example app.py, and save it. Run:
git statusOutput:
On branch main
Your branch is up to date with 'origin/main'.
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
modified: app.py
no changes added to commit (use "git add" and/or "git commit -a")Git tells you:
- One file,
app.py, has been modified - It is not yet staged for commit
git status is safe and useful. Run it often.
Creating and Switching Branches
You rarely commit directly to main in team projects. Instead you create a new branch for each feature or bug fix.
Creating a Branch
Common naming patterns:
| Type | Example Branch Name |
|---|---|
| Feature | feature/add-user-registration |
| Bug fix | fix/login-timeout |
| Chore | chore/update-dependencies |
| Experiment | experiment/new-cache-strategy |
To create and switch to a new branch:
git checkout -b feature/add-login-endpointThis is shorthand for:
git branch feature/add-login-endpoint
git checkout feature/add-login-endpointCheck your branches:
git branchExample output:
main
* feature/add-login-endpointThe star shows your current branch.
Switching Between Branches
If you already created a branch:
git checkout main
git checkout feature/add-login-endpointGit will refuse to switch branches if you have uncommitted changes that would be overwritten. In that case you must commit, stash, or discard those changes first.
Making and Inspecting Changes
Once you are on your feature branch, you change code as needed.
Editing Files
Example backend project structure:
todo-api/
app/
main.py
models.py
routes.py
tests/
test_tasks.pyYou might:
- Add a new route in
routes.py - Change a model in
models.py - Add a test in
test_tasks.py
After edits, run:
git statusExample output:
On branch feature/add-login-endpoint
Changes not staged for commit:
modified: app/routes.py
modified: app/models.py
Untracked files:
tests/test_auth.pyThis tells you:
- Two tracked files are modified
- One new file is untracked
Viewing What Changed
To see the exact changes, use git diff.
Diff of all unstaged changes
git diffExample output:
diff --git a/app/routes.py b/app/routes.py
index 1234567..89abcde 100644
--- a/app/routes.py
+++ b/app/routes.py
@@ -1,4 +1,9 @@
-from fastapi import APIRouter
+from fastapi import APIRouter, HTTPException
router = APIRouter()
+@router.post("/login")
+def login(username: str, password: str):
+ # temporary implementation
+ return {"token": "fake-token"}
This shows additions starting with + and deletions starting with -.
Diff of a specific file
git diff app/models.py
Use q to quit the diff viewer.
Staging Changes with `git add`
Before you commit, you must stage the changes you want to include.
Think of staging as selecting which changes go into the next snapshot.
Staging All Changes
To stage everything at once:
git add .or
git add -AThis includes:
- Modified tracked files
- New files
- Deleted files
Use this only when you are sure that all changes belong together.
Staging Specific Files
Most of the time, it is better to be explicit.
git add app/routes.py
git add tests/test_auth.pyCheck status:
git statusExample output:
On branch feature/add-login-endpoint
Changes to be committed:
modified: app/routes.py
new file: tests/test_auth.py
Changes not staged for commit:
modified: app/models.pyNow:
routes.pyandtest_auth.pyare stagedmodels.pyis still unstaged and will not be part of the next commit
Staging Parts of a File (Optional but Useful)
Sometimes a file has unrelated changes that you want in separate commits.
You can stage interactively:
git add -p app/routes.pyGit will show you each change chunk and ask if you want to stage it.
This is advanced but very useful for clean history.
Writing Commits
Once you have staged the correct changes, you create a commit. A commit is a snapshot with a message that explains why you changed the code.
Creating a Commit
git commit -m "Add basic login endpoint and tests"Check status again:
git statusExample:
On branch feature/add-login-endpoint
Changes not staged for commit:
modified: app/models.py
nothing added to commit but untracked files present (use "git add" to track)Your commit was created with the staged changes only.
The unstaged changes remain in your working directory.
Good Commit Messages
A clear commit message is very important for future you and for your teammates.
Some guidelines:
- Use the imperative form: "Add", "Fix", "Update" instead of "Added" or "Fixes"
- Be specific: explain the intent of the change
- Keep the summary line short, around 50 characters
Examples:
Add login endpoint and auth testsFix task ordering in list endpointUpdate README with setup instructionsRefactor user service to use repository
Bad examples:
ChangesFixWork in progress
Important rule: Every commit should represent a logical, consistent change that can be explained in one sentence.
Multiple Commits for One Task
A full feature might need several commits, for example:
Add User model and migrationImplement login endpointAdd tests for login endpoint
Small, focused commits are easier to review and debug.
Viewing History and Details
To see your commit history:
git logExample output:
commit 7c9a1e6f0d0c3b6f2cb22b6dabae129a85f46899 (HEAD -> feature/add-login-endpoint)
Author: Your Name <you@example.com>
Date: Thu Aug 22 14:37:10 2026 +0000
Add login endpoint and auth tests
commit 5ab3c884a8da1e5910f8207b3c229e4b1a942c46 (origin/main, main)
Author: Teammate <teammate@example.com>
Date: Wed Aug 21 10:12:01 2026 +0000
Add task listing endpointUseful options:
git log --onelineshort viewgit log --oneline --graph --allsimple graphical representation
To see changes of a specific commit:
git show 7c9a1e6You can copy the first few characters of the commit hash.
Pushing Your Work to the Remote
So far your commits exist only on your machine. To share them or create a Pull Request, you must push them to the remote repository.
First Push of a New Branch
If your branch does not exist on the remote yet:
git push -u origin feature/add-login-endpointExplanation:
originis the default name of the remote you cloned from-usetsorigin feature/add-login-endpointas the upstream, so next time you can just typegit push
Next pushes on the same branch:
git pushPushing Updates
After more commits, just run:
git pushIf someone else or a CI system already changed the remote version of your branch, Git might refuse to push and tell you to pull first. We will cover this next.
Pulling Updates from Remote
To get changes from the remote into your local branch use:
git pullThis is equivalent to:
git fetch
git mergeUpdating main
You will frequently update your local main branch:
git checkout main
git pull origin main
This pulls the latest changes from origin/main into your local main.
Updating a Feature Branch
There are two common approaches:
- Merge latest main into your feature branch:
git checkout feature/add-login-endpoint
git merge main- Rebase your branch on top of main (more advanced, typically used in clean-history workflows). In beginner teams, a simple merge is usually enough and safer.
After pulling or merging, check status and run tests to ensure everything works.
Handling Simple Merge Conflicts
Sometimes git pull or git merge will result in a conflict. This happens when Git cannot automatically decide how to combine changes.
Example Conflict Scenario
- Teammate changes
app/routes.pyinmain - You also changed
app/routes.pyin your branch - You run:
git checkout main
git pull origin main
git checkout feature/add-login-endpoint
git merge mainGit output:
Auto-merging app/routes.py
CONFLICT (content): Merge conflict in app/routes.py
Automatic merge failed; fix conflicts and then commit the result.Conflict Markers
Open the file with the conflict:
@app.get("/tasks")
def list_tasks():
<<<<<<< HEAD
return task_service.get_all_tasks()
=======
return task_service.list_all()
>>>>>>> mainExplanation:
<<<<<<< HEADshows your current branch version=======separates the two versions>>>>>>> mainshows the version from the branch you merged in
You must edit the file manually and choose or combine the correct version. For example:
@app.get("/tasks")
def list_tasks():
# Use new unified service method
return task_service.list_all()When finished, remove all conflict markers.
Completing the Merge
After fixing all conflicts in all files:
git add app/routes.py
git commitGit will open an editor with a default merge commit message, or you can set it from the command line:
git commit -m "Merge branch 'main' into feature/add-login-endpoint"Then push:
git pushYou have now resolved the conflict and updated your branch.
Typical Workflow Example: Adding a New API Endpoint
To make it concrete, here is a full example of a simple daily workflow.
1. Update main
git checkout main
git pull origin main2. Create a feature branch
git checkout -b feature/add-completed-filter
Goal: Add a completed query parameter to the tasks list endpoint.
3. Implement the change
Edit app/routes.py:
from fastapi import APIRouter, Query
@router.get("/tasks")
def list_tasks(completed: bool | None = Query(default=None)):
return task_service.list_tasks(completed=completed)
Edit tests/test_tasks.py and add tests.
4. Check status and diff
git status
git diffVerify that only the intended changes are present.
5. Stage files
git add app/routes.py tests/test_tasks.pyCheck:
git statusOutput should list the two files under "Changes to be committed".
6. Commit
git commit -m "Add completed filter to tasks list endpoint"7. Push
git push -u origin feature/add-completed-filter8. Create Pull Request / Merge Request
- Go to GitHub or GitLab
- Open a new Pull Request from
feature/add-completed-filtertomain - Add description and assign reviewers
9. Apply review changes (if any)
Reviewer asks you to adjust tests.
Edit files again, then:
git status
git add tests/test_tasks.py
git commit -m "Adjust completed filter tests to check default value"
git pushThe Pull Request updates automatically.
10. Merge and cleanup
After approval, merge the Pull Request through the web interface.
Locally:
git checkout main
git pull origin main
git branch -d feature/add-completed-filter # delete local branch
git push origin --delete feature/add-completed-filter # optional, delete remote branchCommon Commands Quick Reference
| Task | Command example |
|---|---|
| Clone repository | git clone URL |
| Check branch and status | git status |
| List branches | git branch |
| Create and switch to new branch | git checkout -b feature/name |
| Switch to existing branch | git checkout main |
| See changes (unstaged) | git diff |
| See staged changes | git diff --cached |
| Stage specific file | git add path/to/file.py |
| Stage all changes | git add . |
| Commit with message | git commit -m "Message" |
| Show history | git log or git log --oneline |
| Push new branch | git push -u origin feature/name |
| Push existing branch | git push |
| Pull changes into current branch | git pull |
| Merge another branch into current | git merge main |
| Delete local branch | git branch -d feature/name |
| Delete remote branch | git push origin --delete feature/name |
Key daily rules for Git workflow
- Always work in a branch, not directly on
main, in team projects. - Run
git statusandgit diffbefore every commit. - Keep commits small and focused, with clear messages.
- Pull and update
mainregularly, especially before starting new work.
By practicing this workflow repeatedly in your backend projects, Git will become a natural part of how you develop features and collaborate with others.
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!