3.9. Creating Your First Repository
Table of Contents
Why Repositories Matter
When you write code, you need a place to store it, track changes, and collaborate with others. A Git repository is that place.
A repository, or “repo,” is:
- A folder that contains your project files.
- A hidden
.gitfolder that stores all history and metadata. - The basic unit you push to and pull from hosting services like GitHub and GitLab.
You will create two kinds of repositories:
- Local repository on your own computer.
- Remote repository on a server like GitHub or GitLab.
You can work completely locally, but most real projects use both.
Rule: Every serious project should live in a version-controlled repository, not in random folders like final_version_new2_really_final/.
In this chapter, you will:
- Create a local repository from scratch.
- Create a remote repository on GitHub and GitLab.
- Connect your local and remote repositories.
- Perform your first commit and push.
For all examples, you need Git installed and basic command-line knowledge from previous chapters.
Creating a Local Repository
You can create a new repository from scratch or turn an existing folder into a repository. Both ways use the same Git command: git init.
Creating a New Project Folder
Pick a folder where you keep your code, for example ~/projects or C:\Users\you\code.
Example on Linux/macOS:
mkdir -p ~/projects/backend-demo
cd ~/projects/backend-demoExample on Windows (PowerShell or cmd):
mkdir C:\code\backend-demo
cd C:\code\backend-demoNow this folder is just a normal directory with no Git history.
Initializing the Repository
Inside the project folder, run:
git initGit output will be similar to:
Initialized empty Git repository in /home/you/projects/backend-demo/.git/
Git created a hidden .git folder. This turns the directory into a repository.
You can verify that Git sees this folder as a repo:
git statusYou should see something like:
On branch master
No commits yet
nothing to commit (create/copy files and use "git add" to track)
The exact branch name might be master or main depending on your Git version.
Rule: Never manually edit or delete files inside the .git folder. Git manages it. Breaking .git can destroy your history.
Adding a First File
Create a simple file so the repo has content.
Example:
echo "# Backend Demo Project" > README.mdCheck status again:
git statusYou should see:
Untracked files:
(use "git add <file>..." to include in what will be committed)
README.md“Untracked” means Git sees the file but is not tracking it yet.
Initial Commit
To save a snapshot of your project, you create a commit. A commit is a recorded state of tracked files at a point in time.
Staging Changes with `git add`
You first tell Git which files to include in the commit. This is called staging.
git add README.mdCheck status:
git statusYou should see:
Changes to be committed:
(use "git restore --staged <file>..." to unstage)
new file: README.md“Changes to be committed” means staged.
You can also stage everything in the current directory:
git add .Use this carefully, so you do not accidentally add files you do not want in the repo.
Writing the First Commit
Now create your first commit with a message:
git commit -m "Initial commit: add README"If Git does not yet know who you are, it may show an error like:
*** Please tell me who you are.
Run
git config --global user.email "you@example.com"
git config --global user.name "Your Name"Set your name and email:
git config --global user.name "Your Name"
git config --global user.email "you@example.com"Then run the commit again.
After committing, check status:
git statusShould show:
On branch master
nothing to commit, working tree clean“Working tree clean” means everything is committed and there are no new changes.
Viewing History
To see your commit:
git logYou will see something like:
commit 3fbdf1a2b8c5e1234567890abcdef1234567890 (HEAD -> master)
Author: Your Name <you@example.com>
Date: Thu Aug 1 12:34:56 2026 +0000
Initial commit: add READMEThis confirms your repository has at least one commit.
Creating a GitHub Repository
Now you will create a remote repository on GitHub and connect it to your local one.
Creating a GitHub Account
If you do not have one:
- Go to https://github.com.
- Click “Sign up.”
- Follow the steps to create an account and verify your email.
You can use the free plan. It is enough for personal and learning projects.
Creating a New Repository on GitHub
Once logged in:
- On the top right, click the + icon.
- Choose New repository.
You will see a form with several fields. A typical setup:
| Field | Example value | Notes |
|---|---|---|
| Owner | your-username | Your GitHub account |
| Repository name | backend-demo | Use short, lowercase, hyphen-separated name |
| Description | First backend demo repo | Optional but helpful |
| Visibility | Public or Private | Public is fine for learning |
| Initialize... | Leave all unchecked | Especially do not add a README if you already have one locally |
Click Create repository.
After creation, GitHub shows a page with instructions. You will see something like:
…or push an existing repository from the command line
git remote add origin https://github.com/your-username/backend-demo.git
git branch -M main
git push -u origin mainYou will use these instructions in the next section.
Connecting Local and Remote
You now have:
- A local repository with at least one commit.
- An empty remote repository on GitHub.
Next you need to link them so you can push and pull.
Adding the Remote
From inside your local project folder, run the command GitHub provided (adjusted for your URL):
git remote add origin https://github.com/your-username/backend-demo.gitThis means:
remote addcreates a new remote connection.originis the standard default name for the main remote.- The URL points to your GitHub repository.
You can confirm the remote:
git remote -vYou should see:
origin https://github.com/your-username/backend-demo.git (fetch)
origin https://github.com/your-username/backend-demo.git (push)Setting the Default Branch (if needed)
New Git installations usually use main as the default branch. Older setups might use master.
Check your branch:
git branch
If you see master and you want to rename it to main (recommended to match GitHub default):
git branch -M main
The -M flag forces the rename even if main exists.
Pushing to GitHub (First Push)
Now send your local commits to GitHub:
git push -u origin mainWhat this means:
pushsends commits to a remote.originis the remote name.mainis the branch you are pushing.-usetsorigin mainas the default upstream branch, so later you can just typegit push.
Git will ask you to authenticate. This can happen in several ways:
- Web-based login popup.
- Personal Access Token instead of password.
- GitHub CLI or SSH keys.
For beginners, the browser or token method is common.
When the push succeeds, go back to your GitHub repository page and refresh. You should now see your files and commit.
Rule: After git push completes with no errors, your code and history are stored safely on GitHub. This protects you if your laptop is lost or your disk fails.
Creating a GitLab Repository
GitLab is an alternative to GitHub. The process is very similar. You can learn both, because many companies use GitLab.
Creating a GitLab Account
If you do not have one:
- Go to https://gitlab.com.
- Click “Register.”
- Fill in the details and verify your email.
Creating a New Repository on GitLab
In GitLab, projects are repositories. After logging in:
- Click New project or + and then New project.
- Choose Create blank project.
Fill the form:
| Field | Example value | Notes |
|---|---|---|
| Project name | backend-demo | Same style as GitHub |
| Project slug | backend-demo | Usually auto-filled from the name |
| Project URL | Keep default / your-username | Where your project lives in GitLab |
| Visibility level | Public or Private | Public is fine for learning |
| Initialize repo | Uncheck “Initialize repository with a README” if you already have one locally |
Click Create project.
On the empty project page, GitLab shows instructions like:
…push an existing folder
cd existing_folder
git init
git remote add origin https://gitlab.com/your-username/backend-demo.git
git add .
git commit -m "Initial commit"
git push -u origin mainSince you already have a local repo and commit, you only need to:
- Add the remote.
- Push.
Connecting and Pushing to GitLab
You have two options:
- Use the same local project and add GitLab as another remote.
- Create a separate local project for GitLab.
For learning, it is useful to see how to handle multiple remotes.
Adding GitLab as a Second Remote
From inside your existing project folder:
git remote add gitlab https://gitlab.com/your-username/backend-demo.gitNow you have two remotes:
git remote -vOutput:
gitlab https://gitlab.com/your-username/backend-demo.git (fetch)
gitlab https://gitlab.com/your-username/backend-demo.git (push)
origin https://github.com/your-username/backend-demo.git (fetch)
origin https://github.com/your-username/backend-demo.git (push)To push to GitLab:
git push -u gitlab mainYour project is now hosted on both GitHub and GitLab.
If you prefer to have separate projects, you can repeat the earlier steps in another local directory and follow GitLab’s own command examples.
Creating a .gitignore File
Many files should not be stored in Git, for example:
- Temporary files.
- Compiled artifacts.
- Local configuration.
- Virtual environment folders like
venv/.
You normally add a .gitignore file to tell Git which files or folders to ignore.
In your project:
echo "venv/" > .gitignore
echo "__pycache__/" >> .gitignore
echo "*.pyc" >> .gitignoreCheck:
cat .gitignoreYou should see:
venv/
__pycache__/
*.pycStage and commit:
git add .gitignore
git commit -m "Add basic Python .gitignore"
git push # uses origin main by default if set earlier
git push gitlab main # if you want GitLab to get this tooNow these paths are ignored locally and will not be accidentally committed.
Basic Everyday Workflow Example
To make this concrete, here is a simple daily sequence for working on a backend project with your new repository.
- Start work
cd ~/projects/backend-demo
git status- Create or edit files
touch app.py
echo "print('Hello backend')" > app.py- Check what changed
git status- Stage changes
git add app.py- Commit with a clear message
git commit -m "Add simple hello backend script"- Push to GitHub
git push- Optionally push to GitLab
git push gitlab mainRepeat this cycle as you build out your backend code.
Common Problems and Fixes
Mistyped Remote URL
If you added the wrong remote URL:
git remote set-url origin https://github.com/your-username/correct-name.git
Check again with git remote -v.
Forgot to Initialize Before Adding
If you forgot git init and git remote add fails, run:
git init
git remote add origin <url>Then proceed as usual.
Nothing to Push
If git push says:
Everything up-to-dateBut you expect files on GitHub, make sure you:
- Added files with
git add. - Committed with
git commit. - Pushed the correct branch to the correct remote.
Summary
You now know how to:
- Create a local Git repository with
git init. - Add files, make your first commit, and see history.
- Create remote repositories on GitHub and GitLab.
- Connect local and remote with
git remote add. - Push your code with
git push. - Use
.gitignoreto keep unwanted files out of your repo.
With this foundation, you are ready to follow the Basic Git Workflow in later chapters and use repositories for all your backend development projects.
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!