3.7. Git
Table of Contents
Why Git Matters for Backend Developers
Git is the standard tool for tracking changes in code. Almost every backend job expects you to know it. You will use Git to:
- Save versions of your code over time
- Go back to older versions when something breaks
- Work with other developers on the same project without overwriting each other
- Review and discuss code changes in pull requests or merge requests
In this chapter you will focus on what makes Git useful in your daily backend work, not on every possible command.
What Git Actually Tracks
Git is a version control system. It keeps a history of:
- Which files changed
- What changed inside those files
- Who changed them and when
- Messages explaining why the change was made
Git does not store a copy of the entire project for each version. Instead, it stores a series of snapshots plus differences between them.
Imagine a project folder like this:
my-api/
app.py
models.py
requirements.txt
README.mdWhen you start using Git, it begins to track versions of these files. Every time you commit, you create a new snapshot of the files that changed.
Local vs Remote Repositories
You will often hear about:
- Local repository: lives on your machine, inside your project folder
- Remote repository: lives on a server, for example GitHub or GitLab
You can work entirely with a local repository, but for collaboration and backup you almost always push your changes to a remote.
A typical backend workflow:
- Clone a remote repository to create a local copy.
- Work locally, changing files and committing.
- Push your commits back to the remote.
- Your teammates pull those commits into their own local copies.
Basic Git Concepts
Here are the most important concepts you will use daily.
| Concept | What it is | Simple analogy |
|---|---|---|
| Repository (repo) | A project folder tracked by Git, with its full history | A library with all editions of a book |
| Commit | A snapshot of your changes with a message | A saved game checkpoint |
| Branch | A line of development, separate from others | A different storyline in your game |
| Working tree | Your current files on disk | The page you are currently editing |
| Staging area | A temporary area where you prepare changes for a commit | A basket of pages you are about to save |
| Remote | A copy of the repo on another computer or server | A backup library in another city |
Important rule:
Never commit secrets such as passwords, API keys, private keys, or database URLs to Git.
Creating a New Git Repository Locally
You usually start tracking an existing project with Git like this:
cd my-api
git init
This creates a hidden .git folder inside my-api. That folder contains all of Git’s data and history.
You can check the repo status:
git statusIf you have not added or committed anything yet, you will see something like:
On branch master
No commits yet
Untracked files:
(use "git add <file>..." to include in what will be committed)
app.py
requirements.txtTracking Files: Add and Commit
Git has three main states for files:
- Untracked: Git does not know about this file yet
- Tracked but modified: Git knows the file, and it has changes not yet committed
- Staged: The file is ready to be committed
Example: First Commit
Imagine you create a simple backend entry point:
# app.py
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Hello, world"}Now you want to save this version in Git.
- See what changed:
git status- Stage the file:
git add app.py- Commit it:
git commit -m "Add basic FastAPI app"
The -m flag adds a commit message. Messages should briefly explain what and optionally why.
Important rule:
Each commit should represent a logical, small change. Avoid huge commits that mix many unrelated changes.
Staging multiple files
You can stage all new and modified files:
git add .Then commit:
git commit -m "Implement user model and basic routes"Or stage specific files:
git add app.py models.py
git commit -m "Refactor user model and endpoints"Seeing What Changed
You often want to see exactly what has changed before committing.
- Show changes that are not staged:
git diff- Show changes that are staged and will be committed:
git diff --stagedExample output:
diff --git a/app.py b/app.py
index 3f3c0c1..a9f8b6d 100644
--- a/app.py
+++ b/app.py
@@ -1,5 +1,8 @@
from fastapi import FastAPI
app = FastAPI()
+
+@app.get("/health")
+def health_check():
+ return {"status": "ok"}
This diff shows that you added a /health endpoint. This is very common in backend apps.
Ignoring Files with .gitignore
Some files should not be tracked. Typical examples in backend projects:
- Virtual environment folders (for example
venv/) - Compiled files (for example
__pycache__/) - Local configuration with secrets (for example
.env) - Logs (for example
logs/)
You put these patterns into a file named .gitignore in your project root.
Example .gitignore for a Python backend:
# Python
__pycache__/
*.pyc
# Environments
.env
venv/
.venv/
# IDEs
.vscode/
.idea/
# Logs
logs/
*.log
After adding .gitignore, run:
git add .gitignore
git commit -m "Add .gitignore for Python backend project"If you accidentally committed a file that should be ignored, you must remove it from the repository history. At minimum, run:
git rm --cached secret.env
git commit -m "Stop tracking secret.env"But if secrets were committed, you should change the secret immediately in your production systems.
Viewing History
To see the list of commits:
git logYou will see something like:
commit 9e7c6f5a1b...
Author: Alice Backend <alice@example.com>
Date: Mon Aug 26 10:12:34 2026 +0000
Add user registration endpoint
commit 3a2b1c4d2e...
Author: Alice Backend <alice@example.com>
Date: Mon Aug 26 09:45:12 2026 +0000
Initialize FastAPI projectShorter format:
git log --onelineExample:
9e7c6f5 Add user registration endpoint
3a2b1c4 Initialize FastAPI projectThis helps you see the progression of your backend features.
Undoing Local Changes Safely
You will often need to undo mistakes. There are several levels of "undo."
1. Undo uncommitted changes in a file
If you changed a file but have not staged it and want to revert it to the last commit:
git checkout -- app.py
This discards your local modifications to app.py.
2. Unstage a file
If you did git add app.py by mistake:
git reset HEAD app.pyThis moves the file out of the staging area, but keeps your edits in the working directory.
3. Revert a committed change
If a commit broke your backend and you want to create a new commit that goes back:
- Find the commit hash with
git log. Example:9e7c6f5. - Run:
git revert 9e7c6f5
This creates a new commit that undoes the changes of 9e7c6f5. This is safe for shared branches.
Important rule:
On branches that others are already using, prefer git revert over rewriting history.
Branches for Backend Features
Branches let you work on features independently of the main code.
mainormaster: usually the stable branch- Feature branches: for example
feature/user-registration,bugfix/fix-login-500
Creating and switching branches
See existing branches:
git branchCreate a new branch:
git branch feature/user-registrationSwitch to it:
git checkout feature/user-registrationOr create and switch in one command:
git checkout -b feature/user-registration
Now any commits you make are recorded on this branch, not on main.
Example workflow:
git checkout -b feature/user-registration
# edit files: add registration endpoint
git add app.py models.py
git commit -m "Add basic user registration endpoint"
Later, you will merge this branch back into main.
Merging Branches
When a feature is ready, you usually:
- Make sure your feature branch has the latest changes from
main. - Merge the feature branch into
main.
Example:
# Be on main
git checkout main
# Get latest remote main (explained later)
git pull
# Merge the feature branch
git merge feature/user-registrationIf files were changed in both branches, Git might not know which version to keep. This is a merge conflict.
Example of a merge conflict
Suppose two branches both edit app.py at the same place. After merging, Git might show:
<<<<<<< HEAD
@app.get("/health")
def health_check():
return {"status": "ok"}
=======
@app.get("/health")
def health_check():
return {"status": "healthy"}
>>>>>>> feature/update-health-messageYou must edit the file to resolve the conflict. For example, pick one version:
@app.get("/health")
def health_check():
return {"status": "ok"}Then:
git add app.py
git commit -m "Resolve merge conflict in health_check"You will handle many conflicts in real backend projects when several developers touch the same logic.
Working with Remote Repositories
Remotes let you share your code and collaborate.
You typically start by cloning an existing remote repository rather than running git init.
Cloning a repository
From a remote URL (for example from GitHub):
git clone https://github.com/your-username/my-api.gitThis:
- Creates a folder
my-api - Sets up a local repository
- Connects it to the remote named
origin
Change into the folder:
cd my-apiChecking remotes
See configured remotes:
git remote -vExample:
origin https://github.com/your-username/my-api.git (fetch)
origin https://github.com/your-username/my-api.git (push)Pulling changes
To get the latest changes from the remote branch you are on:
git pullThis is a combination of:
git fetch
git merge
git fetch downloads new commits. git merge integrates them into your local branch.
Pushing changes
Once you have local commits you want to share:
git pushIf this is a new branch not yet on the remote:
git push -u origin feature/user-registration
The -u flag sets origin/feature/user-registration as the default remote branch. Next time, you can simply run:
git pushCommon Git Commands Cheat Sheet
Here is a small table you can refer to while learning:
| Action | Command example |
|---|---|
| Initialize a repo | git init |
| Clone a repo | git clone <url> |
| Check status | git status |
| Stage a file | git add app.py |
| Stage all changes | git add . |
| Commit staged changes | git commit -m "Message" |
| See history | git log or git log --oneline |
| See unstaged changes | git diff |
| See staged changes | git diff --staged |
| Create a branch | git branch feature/auth |
| Switch branch | git checkout feature/auth |
| Create and switch | git checkout -b feature/auth |
| Merge a branch into current branch | git merge feature/auth |
| Add a remote | git remote add origin <url> |
| Show remotes | git remote -v |
| Pull from remote | git pull |
| Push to remote | git push |
| Undo local file changes | git checkout -- app.py |
| Unstage a file | git reset HEAD app.py |
| Revert a commit | git revert <commit-hash> |
Example: Simple Backend Workflow with Git
Walk through a small, realistic example.
- Clone a backend project
git clone https://github.com/example-org/todo-api.git
cd todo-api- Create a branch for a new feature
git checkout -b feature/add-due-date- Edit code
Update models.py and routes.py to add a due_date field to tasks.
- Check what changed
git status
git diff- Stage and commit
git add models.py routes.py
git commit -m "Add due_date field to Task model and endpoints"- Push to remote
git push -u origin feature/add-due-date- Open a pull request / merge request
In GitHub or GitLab, you select the branch feature/add-due-date and open a PR into main. Your teammates review your changes.
- Update local main after merge
After the feature is merged:
git checkout main
git pullThis is the pattern you will repeat in almost every backend project.
Good Practices for Backend Projects with Git
- Commit often, but meaningfully: each commit should be a logical unit, for example "Add login endpoint" or "Validate request body for registration".
- Write helpful messages: "Fix bug" is not helpful. "Fix 500 error when email is missing in registration" is.
- Use branches per feature: do not develop everything on
main. - Do not commit generated or build files: for example migrations can be committed, but compiled binaries should usually not be.
- Always pull before starting new work: keep your local branch updated before editing.
Important rule:
Never commit the .env file or any file containing production secrets. Use .gitignore and secret management tools instead.
With these basics, you can already participate in real backend projects, share your work, and collaborate through GitHub or GitLab, which you will explore in the next chapters.
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!