3.3. Command Line Basics
Table of Contents
Why the Command Line Matters for Backend Developers
As a backend developer you will spend a lot of time in a terminal. You will:
- Start and stop servers
- Run tests
- Manage databases
- Inspect logs
- Work with Git
- Deploy applications
The command line gives you speed, scripting power, and remote access. You do not need to become a Linux guru now, but you must be comfortable with core commands and how to move around.
This chapter focuses on the basics that you will use almost every day.
Rule: For backend work, always know where you are in the filesystem, what files exist there, and what command you are running. A wrong command in the wrong directory can damage your project or system.
Throughout the examples, $ represents the shell prompt. You do not type the $ itself, only what comes after it.
Example:
$ pwd # You type: pwd (then press Enter)Opening a Terminal
How you open a terminal depends on your operating system.
- Linux
- Search for “Terminal” in your applications menu.
- Common names: Terminal, Konsole, GNOME Terminal, xterm.
- Shortcut on many systems:
Ctrl + Alt + T. - macOS
- Open Spotlight (
Cmd + Space), type “Terminal”, press Enter. - Or use iTerm2 if you install it later.
- Windows
For backend development, prefer one of: - Windows Terminal (from Microsoft Store)
- PowerShell
- WSL (Windows Subsystem for Linux) with a Linux distribution
In code examples, Linux, macOS, and WSL behave almost the same. PowerShell syntax sometimes differs, but you can usually adapt easily. If possible, use WSL so you get a Linux environment, which matches most backend servers.
The Prompt and Running Commands
A shell displays a prompt to show it is ready for a command. It often includes your user name, machine name, and current directory:
user@machine:~/projects/myapp$You then type a command, possibly with options and arguments:
$ command-name [options] [arguments]For example:
$ ls -l /etclsis the command-lis an option (also called a flag)/etcis an argument (what the command should act on)
Rule: Commands are case sensitive on Linux and macOS. LS is not the same as ls.
You can run built-in commands or programs installed on your system. Press Enter to execute.
Getting Help
You never need to memorize everything. Use built‑in help.
`--help` option
Many commands support:
$ command --helpExamples:
$ ls --help
$ mkdir --helpThis usually prints a short usage summary.
`man` pages
On Linux and macOS, you often have manual pages:
$ man lsUse:
Up/Downarrows orPageUp/PageDownto scrollqto quit
If man pages are missing in containers or minimal systems, rely on --help or online documentation.
`help` for shell built‑ins
Some commands are built into the shell, for example cd in bash:
$ help cdUnderstanding the Filesystem: Paths
A filesystem is organized like a tree. You navigate it with paths.
Absolute vs relative paths
- Absolute path: Starts from the filesystem root.
- On Linux/macOS:
/is the root directory. - Examples:
/home/user,/var/log,/usr/bin/python3 - Relative path: Starts from your current directory.
- Examples:
src,../logs,./main.py
Common special entries:
| Path | Meaning |
|---|---|
. | Current directory |
.. | Parent directory |
~ | Your home directory (Linux/macOS, WSL) |
Examples:
$ cd ~/projects # Go into "projects" in your home directory
$ cd .. # Go to parent directory
$ ls ./src # List contents of "src" inside current directoryWhere Am I? `pwd`
To know your current directory, use pwd (print working directory):
$ pwd
/home/user/projects/myapp
You will use pwd a lot while learning.
Example workflow:
$ pwd
/home/user
$ cd projects
$ pwd
/home/user/projectsListing Files: `ls`
To see what files and folders are in the current directory:
$ lsYou can also specify a path:
$ ls /etcUseful options:
| Command | Description |
|---|---|
ls | List names only |
ls -l | Long format with permissions and dates |
ls -a | Include hidden files (names start with .) |
ls -la or ls -al | Long format plus hidden files |
Example:
$ ls -la
drwxr-xr-x 8 user user 4096 Aug 25 10:00 .
drwxr-xr-x 10 user user 4096 Aug 25 09:00 ..
-rw-r--r-- 1 user user 220 Aug 25 10:00 .bash_logout
-rw-r--r-- 1 user user 3771 Aug 25 10:00 .bashrc
drwxr-xr-x 3 user user 4096 Aug 25 10:10 myappMoving Around: `cd`
cd changes your current directory.
Basic usage:
$ cd /absolute/path # Use an absolute path
$ cd relative/path # Use a relative path
$ cd # Go to your home directory
$ cd ~ # Also go to home
$ cd .. # Go up one directoryExample navigation:
$ pwd
/home/user
$ cd projects
$ pwd
/home/user/projects
$ cd myapp/src
$ pwd
/home/user/projects/myapp/src
$ cd ..
$ pwd
/home/user/projects/myappCreating Directories and Files: `mkdir` and `touch`
`mkdir` to create directories
$ mkdir myproject
$ ls
myproject
To create nested directories in one go, use -p:
$ mkdir -p myproject/app/templates
Without -p, mkdir fails if parent directories do not exist.
`touch` to create empty files
$ cd myproject
$ touch main.py
$ ls
main.py
If the file already exists, touch updates its last modified time but does not change its content.
Example project setup:
$ mkdir -p myapi/app
$ cd myapi/app
$ touch __init__.py main.py models.py
$ ls
__init__.py main.py models.pyViewing File Contents: `cat`, `less`, `head`, `tail`
Backend developers often inspect configuration files and logs from the terminal.
`cat` to print entire file
$ cat main.py
print("Hello, backend!")
For small files, cat is fine. For large files, it can flood your terminal.
`less` to scroll
less lets you scroll through long files:
$ less access.logControls:
Up/Downork/jto scrollqto quit/text+ Enter to search fortextnfor next match
`head` and `tail`
To see only the first or last lines:
$ head my.log # First 10 lines
$ tail my.log # Last 10 lines
$ head -n 20 my.log # First 20 lines
$ tail -n 50 my.log # Last 50 lines
tail -f is very useful for logs. It follows the file as it is written:
$ tail -f myapp.logThis shows new log entries as your backend runs.
Creating and Editing Files
You will need a text editor that runs in a terminal or in your GUI.
Simple file creation with redirection
You can quickly create small files using cat and redirection:
$ cat > hello.py
print("Hello from the command line")
# Press Ctrl + D to finish inputNow:
$ python hello.py
Hello from the command lineTerminal text editors
Common terminal editors:
nano(easiest for beginners)vimorvi(powerful, but steeper learning curve)emacs
Example with nano:
$ nano main.pyType your code, then:
Ctrl + Oto save, press Enter to confirm file nameCtrl + Xto exit
In many cases you will use a GUI editor or IDE (covered in another chapter), but knowing nano or vim is very helpful on remote servers.
Copying, Moving, and Renaming Files: `cp` and `mv`
Copying: `cp`
cp copies files or directories.
$ cp source.txt dest.txtCopy into a directory:
$ cp config.example.ini config.ini
$ cp main.py backup_main.py
To copy directories, use -r (recursive):
$ cp -r src src_backup
Be careful, cp can overwrite files without warning. Use -i (interactive) to be asked before overwriting:
$ cp -i config.ini /etc/myapp/config.iniMoving and renaming: `mv`
mv moves or renames files and directories.
Rename:
$ mv main_old.py main.pyMove a file into a directory:
$ mv main.py src/Move and rename in one command:
$ mv src/main.py app/server.py
You can also use -i for safety:
$ mv -i config.ini /etc/myapp/config.iniDeleting Files and Directories: `rm` and `rmdir`
Deleting is powerful and often final.
Rule: Check the path twice before running rm. A small mistake can delete important files. There is no “undo” in the shell.
Deleting files: `rm`
$ rm file.txtTo be asked before deleting each file, use:
$ rm -i file.txtDeleting directories
You can remove an empty directory with:
$ rmdir emptydirTo remove a directory and everything in it, use:
$ rm -r mydir
This is dangerous. Add -i to confirm each delete:
$ rm -ri mydirNever run commands like:
rm -rf /
rm -rf *unless you are absolutely sure what you are doing. They can erase huge parts of your filesystem.
For backend projects, a safe pattern is to only delete inside your project directory, not system paths.
Searching Files and Text: `find` and `grep`
You will often search for a file or a piece of configuration.
`find` to locate files and directories
Basic example, find all .py files under current directory:
$ find . -name "*.py"
./main.py
./app/models.py
./tests/test_main.pyExplanation:
.means start from current directory-name "*.py"matches Python files
Find directories named migrations:
$ find . -type d -name "migrations"`grep` to search inside files
Search for a word or phrase in files:
$ grep "DATABASE_URL" config.py
Search recursively in all .py files:
$ grep -R "DATABASE_URL" .
$ grep -R "DATABASE_URL" . --include="*.py"Useful options:
| Option | Meaning |
|---|---|
-i | Case insensitive search |
-n | Show line numbers |
-R | Search directories recursively |
Example:
$ grep -Rin "DEBUG" .
./settings.py:10:DEBUG = TrueRunning Programs: `python`, `pip`, `git`, etc.
The command line is how you run tools used in backend development.
Examples:
$ python main.py
$ python -m pytest # Run tests with pytest
$ pip install fastapi
$ git status
$ git commit -m "Add new endpoint"
$ uvicorn main:app --reload # Run a FastAPI app during developmentEach of these tools comes with its own options and subcommands. You will learn them gradually.
Use --help for each:
$ git --help
$ pip --help
$ uvicorn --helpPipes and Redirection: Combining Commands
The shell lets you connect commands so that the output of one becomes the input of another. This is very powerful.
Standard output and redirection
To send output to a file instead of the screen:
>overwrite file>>append to file
Examples:
$ ls > files.txt # Save ls output to files.txt, overwrite
$ ls >> files.txt # Append ls output to files.txt
$ cat config.py > backup_config.py
If you open files.txt, you will see the list of files.
Pipes `|`
The pipe symbol | passes the output of one command into another.
Example, see only Python files from ls:
$ ls | grep ".py"
main.py
models.pyTail the log file and show only lines containing "ERROR":
$ tail -f myapp.log | grep "ERROR"Pipes are essential for quickly inspecting logs and filtering information during debugging.
Environment Variables Basics
Environment variables are key-value pairs that affect how processes behave. They are often used for configuration and secrets, such as database URLs and API keys.
To print an environment variable:
$ echo $HOME
/home/user
$ echo $PATH
/usr/local/bin:/usr/bin:/bin:...To set an environment variable for a single command:
$ DEBUG=true python main.pyTo set one in the current shell session (bash style):
$ export DEBUG=true
$ echo $DEBUG
trueLater chapters have a dedicated discussion of environment variables, but you already see them often in backend examples, for example:
$ export DATABASE_URL="postgresql://user:pass@localhost:5432/mydb"
$ uvicorn main:app --reloadManaging Processes: `ps`, `kill`, and `Ctrl + C`
When you run a long command, such as a web server, it may keep running until you stop it.
Stopping a foreground process
Most of the time, you can stop the running command with:
Ctrl + C
Example:
$ uvicorn main:app --reload
INFO: Uvicorn running on http://127.0.0.1:8000
# Press Ctrl + C to stopListing processes: `ps`
To see processes related to your shell:
$ ps
PID TTY TIME CMD
1234 pts/0 00:00:00 bash
1300 pts/0 00:00:00 python
1310 pts/0 00:00:00 ps
PID is the process ID.
To see more details:
$ ps aux | grep pythonKilling a process: `kill`
If a process is stuck and does not respond to Ctrl + C, you can use kill with its PID.
$ kill 1300 # Politely ask process 1300 to stop
$ kill -9 1300 # Forcefully kill process 1300 (use only if needed)Command History and Reuse
The shell keeps a history of commands you entered. This saves time.
Uparrow: Previous commandDownarrow: Next commandCtrl + R: Search in history
Example of Ctrl + R:
- Press
Ctrl + R - Type
uvicorn - You see:
(reverse-i-search)uvicorn': uvicorn main:app --reload` - Press Enter to run it again or use arrows to edit.
You can also list the history:
$ history
1 ls
2 cd projects
3 uvicorn main:app --reloadThen run a command by its number:
$ !3This runs the third command from history.
File Permissions Basics
On Linux/macOS, each file has permissions that control who can read, write, or execute it.
View permissions with ls -l:
$ ls -l main.py
-rw-r--r-- 1 user user 120 Aug 25 10:30 main.py
The first part -rw-r--r-- shows:
rreadwwritexexecute
They are grouped for:
- Owner
- Group
- Others
Basic patterns you will see:
| Pattern | Meaning |
|---|---|
-rw-r--r-- | Regular file, owner can edit |
-rwxr-xr-x | Executable file or script |
drwxr-xr-x | Directory |
To make a script executable:
$ chmod +x script.sh
$ ls -l script.sh
-rwxr-xr-x 1 user user ... script.shYou will use permissions more deeply when deploying to servers, but recognizing them now is helpful.
Practical Example: Creating a Simple Project via CLI
Let us combine several commands into a short, realistic workflow.
You want to start a new backend project called todo_api.
# 1. Go to home directory
$ cd ~
# 2. Create a projects directory if it does not exist
$ mkdir -p projects
$ cd projects
# 3. Create a project folder
$ mkdir todo_api
$ cd todo_api
# 4. Create basic structure
$ mkdir app
$ touch app/__init__.py app/main.py
# 5. List structure
$ ls
app
$ ls app
__init__.py main.py
# 6. Edit main.py with nano (or your editor)
$ nano app/main.py
Inside app/main.py, you might write:
def hello():
return "Hello, TODO API"
if __name__ == "__main__":
print(hello())Then run it:
$ python app/main.py
Hello, TODO APIYou have just created a simple project using only command line tools.
Good Habits for Using the Command Line
Some simple habits will save you pain.
Rule: Before running a destructive command like rm, mv, or cp, always:
- Run
pwdto verify where you are. - Run
lsto see what is there. - Double check the full path in your command.
Additional tips:
- Use tab completion. Type part of a file name and press
Tabto auto-complete or see suggestions. - Prefer short, clear commands. For example, use
cd ~/projects/myappinstead of manycd ... - Use history search (
Ctrl + R) instead of retyping long commands. - Keep a notes file with useful commands you use often.
- Do not run commands that you do not understand, especially if they include
rm -rf,sudo, or write to system directories like/etc,/usr, or/var.
Summary
In this chapter you learned:
- How to open and use a terminal
- How to navigate directories with
pwd,ls, andcd - How to create, inspect, copy, move, and delete files and directories with
mkdir,touch,cat,less,cp,mv,rm - How to search for files and text with
findandgrep - How to run programs and combine commands with pipes and redirection
- Basics of environment variables, processes, history, and permissions
These command line basics are enough to start doing real backend work, such as creating projects, running Python scripts, working with Git, and later managing services and servers. In the following chapters you will build on this foundation.
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!