3.8. GitHub and GitLab
Table of Contents
Why Backend Developers Use GitHub and GitLab
As a backend developer, you will almost always store your code on a remote Git hosting platform. The two most popular options are GitHub and GitLab.
Both are built around Git, which you will already have learned as your version control system. Git works locally, on your machine. GitHub and GitLab act as:
- Remote backups of your repositories
- Collaboration platforms for teams
- Integration points for CI/CD, issue tracking, code review, and more
You can think of them as "social networks for code" plus many development tools.
In this chapter, you will see what is common between GitHub and GitLab, and where they differ, especially from a backend beginner's perspective.
Common Features: Git Hosting Platforms
GitHub and GitLab provide very similar core features. Understanding these shared features helps you switch between them easily.
Repositories
A repository (repo) on GitHub or GitLab is the remote copy of your local Git repository.
Typical workflow:
- You have a local repo created with
git initor cloned. - You create a remote repo on GitHub or GitLab (usually via the website).
- You connect local and remote:
git remote add origin git@github.com:username/project-name.git
# or
git remote add origin git@gitlab.com:username/project-name.git- You push your code:
git push -u origin mainFrom now on you can pull and push between your local repo and the remote.
Public vs Private Repositories
- Public repo
Anyone on the internet can see the code. Good for: - Open source projects
- Portfolio projects you want to show to employers
- Private repo
Only you and people you explicitly invite can see the code. Good for: - Commercial projects
- Experiments you are not ready to share
Both GitHub and GitLab support free private repositories for individuals.
Branches and Pull / Merge Requests
You already know Git branches. The hosting platforms add collaboration workflows on top.
Feature Branches
Common pattern:
- You create a branch locally:
git checkout -b feature/add-login- You make changes and commit:
git commit -am "Add basic login endpoint"- You push the branch:
git push -u origin feature/add-loginNow the branch exists on GitHub or GitLab and others can see it.
Pull Requests (GitHub) / Merge Requests (GitLab)
After you push a branch, you usually open a request to merge your changes into the main branch.
- On GitHub, this is called a Pull Request (PR).
- On GitLab, this is called a Merge Request (MR).
They are conceptually the same.
Inside a PR/MR you can:
- See diffs (what changed)
- Add comments to specific lines
- Request reviews from team members
- Run automated tests (CI)
This is central to team development and code quality.
Issues and Project Management
Both platforms support issues which are like tickets or tasks.
Examples:
- "Bug: 500 error when updating user profile"
- "Feature: Add filtering to /tasks endpoint"
- "Refactor: Move database logic to repository layer"
You can:
- Assign issues to people
- Add labels (bug, enhancement, backend, urgent)
- Link issues to PRs/MRs
For backend projects, issues help you organize:
- API endpoints to implement
- Database migrations to design
- Performance bugs to fix
Both platforms also provide more advanced project management tools such as boards and milestones, useful for larger teams.
Wikis and Documentation
Both GitHub and GitLab can provide a wiki section for each repository.
You can document:
- API overview
- Architecture decisions
- Database diagrams
- Deployment steps
Although for many backend projects you will use Markdown files inside the repo (like README.md and docs/ folder), the built-in wiki can be helpful for teams.
GitHub Overview
GitHub is the most widely used Git hosting platform, especially in open source and many companies.
Key Concepts
User Accounts and Organizations
On GitHub you have:
- User account
Your personal profile, e.g.github.com/alex-backend. - Organizations
Shared spaces for teams or companies, e.g.github.com/acme-corp.
Repositories can live either:
- Under your user account:
github.com/alex-backend/my-api - Under an organization:
github.com/acme-corp/payment-service
For a backend developer:
- Your portfolio and side projects usually live in your personal account.
- Company projects are often in an organization.
Stars, Forks, and Watch
GitHub is very social, and you will interact with open source often.
- Star a repo to bookmark or show appreciation.
- Fork a repo to create your own copy under your account.
Example workflow to contribute to an open source backend library:
- Fork the repo.
- Clone your fork.
- Create a branch, make changes, push.
- Open a Pull Request from your fork to the original project.
This is how you might contribute to Python libraries, FastAPI, or any backend tool.
GitHub Pages
GitHub can host static sites from a repo. This is useful to:
- Host project documentation.
- Publish small dashboards or API documentation sites generated from your backend.
For backend documentation you might generate static docs (with tools like MkDocs or Sphinx) and serve them with GitHub Pages.
Creating and Connecting a Repository
Example: you want to put your first backend project on GitHub.
- Create a new repo on GitHub (via the website):
- Name:
task-manager-api - Choose public or private
- Do not initialize with README if you already have one locally.
- On your local machine, in the project folder:
git init
git add .
git commit -m "Initial commit"
git branch -M main
git remote add origin git@github.com:your-username/task-manager-api.git
git push -u origin mainNow your API project is visible on GitHub. Employers and collaborators can see your code structure, tests, and documentation.
GitHub Actions (Overview Only)
GitHub provides GitHub Actions, a built-in CI/CD system. You will use CI/CD in a later chapter, so here just understand:
- You can define workflows in
.github/workflows/*.yml. - For backend projects, these workflows can:
- Run tests on each commit.
- Build Docker images.
- Deploy to servers or cloud platforms.
You do not need details here, just know that GitHub can automatically test and deploy your backend when you push code.
GitLab Overview
GitLab is both a SaaS platform like GitHub (gitlab.com) and a self-hosted product you can run on your own servers. Many companies use GitLab for its integrated toolset.
Hosted vs Self-Hosted
You can use:
- GitLab.com for cloud-hosted repos.
- GitLab CE/EE as an application installed on a company or private server.
Self-hosting is very common in organizations that want full control over their code and CI infrastructure, which is often important for backend systems with sensitive data.
Namespaces, Groups, and Projects
GitLab uses:
- User namespaces for personal projects.
- Groups for organizations, teams, departments.
A project in GitLab is similar to a repository in GitHub.
Examples:
- Personal project:
gitlab.com/alex-backend/url-shortener - Group project:
gitlab.com/acme-corp/billing/payment-service
Groups can also contain subgroups, which can help organize a microservices backend into separate projects.
Merge Requests and Code Review
In GitLab you open Merge Requests (MRs) to merge branches.
Typical backend team workflow:
- Developer creates a feature branch:
feature/add-user-roles- Developer pushes branch to GitLab.
- Developer opens a Merge Request:
- Source branch:
feature/add-user-roles - Target branch:
mainordevelop - CI pipeline runs tests.
- Reviewer checks code, adds comments, and approves.
- MR is merged.
The process is almost identical to GitHub Pull Requests, but the terminology is different.
GitLab CI/CD (Overview Only)
GitLab has built-in CI/CD configured with a .gitlab-ci.yml file in your repo.
Like GitHub Actions, GitLab CI/CD can:
- Run backend tests.
- Build Docker images.
- Deploy services to staging or production.
You will explore CI/CD in a dedicated chapter, but for now understand that GitLab is very strong in this area and many backend teams prefer it because everything is integrated.
GitHub vs GitLab: Practical Comparison for Backend Work
From a beginner backend developer point of view, both platforms can do almost everything you need. However, each has strengths.
High-Level Comparison
| Feature / Aspect | GitHub | GitLab |
|---|---|---|
| Popularity (open source) | Very high, default for many OSS projects | Used by many companies, less for public OSS |
| Account type | User + Organizations | User + Groups + Subgroups |
| Self-hosting | GitHub Enterprise (paid, less common for hobby) | Very common, free Community Edition available |
| Pull / Merge requests | Pull Requests | Merge Requests |
| CI/CD | GitHub Actions | GitLab CI/CD (very integrated) |
| Project management | Projects (classic and new), issues, milestones | Boards, epics, issues, milestones, advanced PM |
| Integration with external apps | Very large ecosystem | Good integration, especially around DevOps |
When You Might Prefer GitHub
- You are building a public portfolio as a beginner backend developer.
- You want to contribute to open source projects like FastAPI, Django, or libraries.
- You want recruiters or hiring managers to easily see your code.
Many companies also use GitHub internally, so learning GitHub is very useful.
When You Might Prefer GitLab
- Your company or client is already using GitLab.
- You need a self-hosted solution for security or compliance.
- You want integrated CI/CD, container registry, and project management in one place.
As a developer, you do not need to choose one forever. You can and probably will use both during your career.
Hosting Your First Backend Project
Let us walk through an example backend project and how you would use GitHub and GitLab in practice. This example is language and framework agnostic.
Example Project: "Notes API"
You build a simple REST API that:
- Creates, reads, updates, deletes notes.
- Stores notes in a PostgreSQL database.
- Has tests and basic documentation.
Structure Locally
Your local folder might look like:
notes-api/
app/
__init__.py
main.py
models.py
routes.py
tests/
test_notes.py
requirements.txt
README.md
.gitignoreYou initialize Git, commit, and everything works locally.
Publishing to GitHub
- Create a new repo on GitHub,
notes-api. - Add it as a remote and push as shown earlier.
Now on GitHub you can:
- Add a README that describes:
- How to run the API locally.
- How to run tests.
- Tag releases for stable versions, such as
v1.0.0. - Open issues for ideas or bugs.
- Invite collaborators.
Later, you can add a basic GitHub Actions workflow such as:
# .github/workflows/tests.yml
name: Run tests
on: [push, pull_request]
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: '3.12'
- run: pip install -r requirements.txt
- run: pytestWhenever you push, tests run automatically.
Publishing to GitLab
If you instead (or also) want to use GitLab:
- Create a project on GitLab,
notes-api. - Add the GitLab URL as another remote, or host there only.
git remote add gitlab git@gitlab.com:your-username/notes-api.git
git push -u gitlab mainOn GitLab you might add a minimal CI file:
# .gitlab-ci.yml
stages:
- test
test-backend:
stage: test
image: python:3.12
script:
- pip install -r requirements.txt
- pytestNow, every push to GitLab triggers tests there.
You could even use both GitHub and GitLab remotes if needed:
git remote -v
# origin git@github.com:your-username/notes-api.git
# gitlab git@gitlab.com:your-username/notes-api.gitThen:
git push origin main
git push gitlab mainThis is not common for production systems but can be useful if you want redundancy or use GitHub for portfolio and GitLab for CI.
Practical Tips for Beginners
Commit Messages and PR/MR Titles
Clear messages and request titles help maintain backend projects.
Examples of good commit messages:
Add POST /notes endpoint with validationFix 500 error when updating note without titleRefactor database session handling
Examples of good PR/MR titles:
Add pagination to GET /notesImplement JWT-based authenticationOptimize queries for notes listing
These make code history and reviews easier.
Protecting Main Branch
On both GitHub and GitLab you can protect your main branch so you:
- Cannot push directly.
- Must use PRs/MRs.
- Must pass tests before merge.
This is important for backend stability, especially once your API is deployed to production. Broken code in main can break real users.
Using Issues to Plan Backend Work
Break work into small, clear issues.
Example set of issues for a new feature:
- "Design database schema for tags"
- "Add models and migrations for tags"
- "Add CRUD endpoints for tags"
- "Add tests for tags API"
- "Update API documentation for tags"
Each issue can map to a branch and a PR/MR. This structure scales well as your backend grows.
Important Concepts to Remember
Key Points About GitHub and GitLab
- Both provide remote Git repositories, collaboration, and CI/CD integration.
- Use branches and Pull Requests / Merge Requests instead of committing directly to main.
- Choose public repos for portfolio and open source, private repos for proprietary or sensitive code.
- GitHub is dominant in open source and hiring visibility. GitLab is very strong for integrated DevOps and self-hosting.
- Use issues and project features to organize backend tasks and bugs.
By understanding GitHub and GitLab early in your backend journey, you prepare yourself to work effectively in almost any modern development team.
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!