Skip to content

Volume ITechnology

3.14.7 — Authentication & Security ​

Until now, the order service believed whoever sent the header X-User: asha. Anyone could type that header and read Asha's orders. This page replaces trust with proof. A customer logs in with a password once and receives a signed token. Every later request carries the token, and the service checks the signature before believing anything in it. Support staff get extra permissions that customers do not, and partner companies get API keys. Along the way you will see how passwords must be stored, what is really inside a JSON Web Token, and the mistakes that turn up again and again in real FastAPI services. Part 8 covers security theory in depth. This page is about building it correctly in Python.

Two words first, because they are often confused.

  • Authentication answers "who are you?" It is proved with a password, a token or a key. Failure is 401 Unauthorized, despite the confusing name.
  • Authorisation answers "are you allowed to do this?" It is checked against permissions. Failure is 403 Forbidden.

1. Storing passwords: slow hashes, never plain text ​

A service must be able to check a password without storing it. If the database leaks, and databases do leak, stored passwords must be useless to the attacker. So we store a hash: the output of a one-way function that is easy to compute and practically impossible to reverse.

But an ordinary hash like SHA-256 is the wrong choice for passwords, because it is fast.

python
import hashlib
import time

start = time.perf_counter()
for _ in range(100_000):
    hashlib.sha256(b"guess").hexdigest()
print(f"100,000 sha256 in {(time.perf_counter() - start) * 1000:.0f} ms")
text
100,000 sha256 in 104 ms

One laptop core tries about a million guesses per second. A graphics card tries billions. An attacker with a leaked table of SHA-256 hashes can test every common password against every user in minutes.

Password hashes are deliberately slow and memory-hungry. The current standard is Argon2, the winner of the 2015 Password Hashing Competition, in its argon2id variant. The pwdlib library, which FastAPI's own documentation now uses, wraps it.

python
import time
from pwdlib import PasswordHash

password_hash = PasswordHash.recommended()                         # (1)

start = time.perf_counter()
stored = password_hash.hash("correct horse battery staple")         # (2)
print(f"hash took {(time.perf_counter() - start) * 1000:.0f} ms")
print(stored)                                                       # (3)
print(password_hash.verify("correct horse battery staple", stored)) # (4)
print(password_hash.verify("wrong guess", stored))
print(password_hash.hash("correct horse battery staple") == stored) # (5)
text
hash took 48 ms
$argon2id$v=19$m=65536,t=3,p=4$ZJY6g/6YcivFP1DxTzx2dw$nIji2aJl12NgeXwJI/sAFY90ut+yKOIvpPe87yOZhuU
True
False
False
  • (1) The recommended settings, which are Argon2id today.
  • (2) About 50 ms per hash. Unnoticeable for one login, and crushing for an attacker who must spend 50 ms of CPU and 64 MB of memory per guess.
  • (3) The stored string records everything needed to check it later: the algorithm, its settings (m=65536 KB of memory, t=3 passes, p=4 lanes), a random salt, and the hash. The salt makes every user's hash different, even when two users choose the same password, so one precomputed table cannot crack them all.
  • (4) verify re-hashes the attempt with the stored settings and salt, and compares.
  • (5) Hashing the same password twice gives a different string, because each hash gets a new salt. That is why you must always use verify, never ==.

Because the settings live inside the stored string, you can raise them in future years. Old hashes still verify, and libraries such as pwdlib can tell you when a stored hash should be upgraded on the user's next successful login. bcrypt is the older, still acceptable choice. Plain SHA-256, MD5, or "encrypted" passwords are never acceptable.

2. Tokens: proving who you are on every request ​

After a correct password, the service gives the client a token to send on every later request, so the password is sent only once. FastAPI uses the conventions of OAuth2, the standard framework for this kind of token exchange. The client sends the token in a header:

text
Authorization: Bearer eyJhbGciOiJIUzI1NiIs...

"Bearer" means "whoever bears this token is treated as its owner", so tokens must be protected like passwords: only over HTTPS, never in URLs, never in logs.

What is inside a JSON Web Token ​

The most common token format is the JSON Web Token, or JWT, pronounced "jot". It is three base64url-encoded parts joined by dots: a header, a payload of claims, and a signature.

python
import base64
import json
from datetime import datetime, timedelta, timezone
import jwt

SECRET = "change-me-to-32-random-bytes-from-a-secret-store"
now = datetime(2026, 10, 21, 9, 0, tzinfo=timezone.utc)
token = jwt.encode({"sub": "42", "scopes": ["orders:read"], "iat": now,
                    "exp": now + timedelta(minutes=15)}, SECRET, algorithm="HS256")   # (1)
print(token)

header, payload, signature = token.split(".")
pad = lambda part: part + "=" * (-len(part) % 4)
print(json.loads(base64.urlsafe_b64decode(pad(header))))                            # (2)
print(json.loads(base64.urlsafe_b64decode(pad(payload))))
text
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiI0MiIsInNjb3BlcyI6WyJvcmRlcnM6cmVhZCJdLCJpYXQiOjE3OTI1NzMyMDAsImV4cCI6MTc5MjU3NDEwMH0.hhj6tzeFyQYEjNMx-1nV4nJeXW7usZKraOcY6tqEFV0
{'alg': 'HS256', 'typ': 'JWT'}
{'sub': '42', 'scopes': ['orders:read'], 'iat': 1792573200, 'exp': 1792574100}
  • (1) The PyJWT library signs the claims. sub, short for subject, is the user's ID. iat is "issued at", exp is the expiry time, and scopes is our own claim listing permissions.
  • (2) Anyone can decode the header and payload. A JWT is signed, not encrypted. Never put anything secret in it.

The signature is what makes it trustworthy. With HS256, it is an HMAC: a SHA-256-based code computed from the header, the payload and the server's secret key. Change one character of the payload, and the signature no longer matches. Only someone holding the secret can produce a valid signature.

python
fake = base64.urlsafe_b64encode(json.dumps(
    {"sub": "1", "scopes": ["admin"], "exp": 9999999999}).encode()).rstrip(b"=").decode()

try:
    jwt.decode(f"{header}.{fake}.{signature}", SECRET, algorithms=["HS256"])   # (1)
except jwt.InvalidSignatureError as error:
    print("InvalidSignatureError:", error)

none_header = base64.urlsafe_b64encode(b'{"alg":"none","typ":"JWT"}').rstrip(b"=").decode()
try:
    jwt.decode(f"{none_header}.{fake}.", SECRET, algorithms=["HS256"])        # (2)
except jwt.InvalidTokenError as error:
    print(type(error).__name__ + ":", error)
text
InvalidSignatureError: Signature verification failed
InvalidAlgorithmError: The specified alg value is not allowed
  • (1) An attacker swapped in a payload claiming admin rights, keeping the old signature. Rejected.
  • (2) A famous old attack: set the header's algorithm to none and drop the signature. Early libraries trusted the header and skipped verification. Always pass an explicit algorithms=[...] list, so the server decides the algorithm, never the token.

HS256 uses one shared secret for signing and checking, which suits a single service. When many services must check tokens issued by one login service, use an asymmetric algorithm such as RS256 or ES256: the login service signs with a private key, and everyone else verifies with the public key, so a compromised checker cannot mint tokens.

The trade-off: JWTs cannot be taken back ​

A JWT is self-contained. The server checks the signature and expiry, with no database lookup. That is fast and scales well. The price is that a stolen token stays valid until it expires, and logging out cannot cancel it. The standard compromise:

  1. Short-lived access tokens, 5 to 15 minutes.
  2. Refresh tokens, long-lived, stored by the server, sent only to one refresh endpoint, and rotated on every use. Revoking a session means deleting its refresh token, and the access token dies within minutes.

For a browser-only app, a server-side session stored in a database or Redis, referenced by an HttpOnly, Secure, SameSite cookie, is often simpler and easier to revoke. JWTs shine when many services or mobile apps need to check identity without sharing a session store.

3. The login and current-user flow in FastAPI ​

Here is the complete flow for the order service. FastAPI's security module provides the OAuth2 pieces, and they appear in the /docs page as a working "Authorize" button.

python
from datetime import datetime, timedelta, timezone
from typing import Annotated
import jwt
from fastapi import Depends, FastAPI, HTTPException, Security, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm, SecurityScopes
from pwdlib import PasswordHash
from pydantic import BaseModel

SECRET_KEY = "load-me-from-settings-never-hard-code"         # (1)
ALGORITHM = "HS256"
ACCESS_TOKEN_MINUTES = 15

password_hash = PasswordHash.recommended()
DUMMY_HASH = password_hash.hash("dummy-password-for-timing")

USERS = {                                                     # stands in for a database table
    "asha@example.com": {"id": 1, "email": "asha@example.com",
                         "password_hash": password_hash.hash("s3cret-pass"),
                         "scopes": ["orders:read"]},
    "ravi@example.com": {"id": 2, "email": "ravi@example.com",
                         "password_hash": password_hash.hash("support-pass"),
                         "scopes": ["orders:read", "refunds:write"]},
}

app = FastAPI()
oauth2_scheme = OAuth2PasswordBearer(                         # (2)
    tokenUrl="token",
    scopes={"orders:read": "Read your orders", "refunds:write": "Issue refunds"})

class Token(BaseModel):
    access_token: str
    token_type: str = "bearer"

def authenticate(email: str, password: str) -> dict | None:
    user = USERS.get(email)
    if user is None:
        password_hash.verify(password, DUMMY_HASH)            # (3)
        return None
    if not password_hash.verify(password, user["password_hash"]):
        return None
    return user

def create_access_token(user: dict, scopes: list[str]) -> str:
    now = datetime.now(timezone.utc)
    claims = {"sub": str(user["id"]), "scopes": scopes, "iat": now,
              "exp": now + timedelta(minutes=ACCESS_TOKEN_MINUTES)}
    return jwt.encode(claims, SECRET_KEY, algorithm=ALGORITHM)

@app.post("/token")
def login(form: Annotated[OAuth2PasswordRequestForm, Depends()]) -> Token:      # (4)
    user = authenticate(form.username, form.password)
    if user is None:
        raise HTTPException(status.HTTP_401_UNAUTHORIZED, "incorrect email or password",
                            headers={"WWW-Authenticate": "Bearer"})              # (5)
    granted = [s for s in form.scopes if s in user["scopes"]] or user["scopes"]  # (6)
    return Token(access_token=create_access_token(user, granted))
  • (1) In a real service this comes from BaseSettings as a SecretStr (3.14.2), generated with secrets.token_urlsafe(32), and stored in a secret manager. A secret in source code is a secret in every copy of the repository.
  • (2) OAuth2PasswordBearer is a dependency class. On each request it reads the Authorization: Bearer … header and returns the token string, or answers 401 if the header is missing. tokenUrl tells the docs page where to log in.
  • (3) If the email does not exist, we still spend the time of a password check. Otherwise "unknown email" would return in 1 ms and "wrong password" in 50 ms, and an attacker could find which emails have accounts, a leak called user enumeration. The error message is also identical for both cases.
  • (4) OAuth2PasswordRequestForm reads the standard login form: username, password and optional scope, sent as form data, not JSON.
  • (5) The WWW-Authenticate header is what the HTTP standard says a 401 should include.
  • (6) A client may ask for fewer permissions than the user has. It never gets more.

Now the dependency that every protected endpoint uses.

python
def get_current_user(security_scopes: SecurityScopes,
                     token: Annotated[str, Depends(oauth2_scheme)]) -> dict:   # (1)
    unauthorized = HTTPException(status.HTTP_401_UNAUTHORIZED, "could not validate credentials",
                                 headers={"WWW-Authenticate": "Bearer"})
    try:
        claims = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])        # (2)
    except jwt.ExpiredSignatureError:
        raise HTTPException(status.HTTP_401_UNAUTHORIZED, "token expired",
                            headers={"WWW-Authenticate": "Bearer"})
    except jwt.InvalidTokenError:
        raise unauthorized
    user = next((u for u in USERS.values() if str(u["id"]) == claims.get("sub")), None)   # (3)
    if user is None:
        raise unauthorized
    missing = [s for s in security_scopes.scopes if s not in claims.get("scopes", [])]   # (4)
    if missing:
        raise HTTPException(status.HTTP_403_FORBIDDEN, f"missing permission: {', '.join(missing)}")
    return user

@app.get("/orders/mine")
def my_orders(user: Annotated[dict, Security(get_current_user, scopes=["orders:read"])]):   # (5)
    return {"customer": user["email"], "orders": ["ORD-1", "ORD-3"]}

@app.post("/orders/{order_id}/refund")
def refund(order_id: str,
           user: Annotated[dict, Security(get_current_user, scopes=["refunds:write"])]):
    return {"refunded": order_id, "by": user["email"]}
  • (1) SecurityScopes is filled in by FastAPI with the scopes the endpoint asked for.
  • (2) Verify the signature, the expiry and the algorithm in one call. Any failure means 401.
  • (3) Load the user, so a deleted or disabled account stops working even if its token has not expired.
  • (4) Authorisation: does the token carry every permission this endpoint requires? If not, 403.
  • (5) Security is Depends plus a list of required scopes. FastAPI also lists those scopes for the endpoint in the OpenAPI document.

Here is the whole flow, request by request.

text
$ curl -X POST localhost:8000/token -d "username=asha@example.com&password=wrong"
{"detail":"incorrect email or password"}                     ← 401

$ curl -X POST localhost:8000/token -d "username=asha@example.com&password=s3cret-pass"
{"access_token":"eyJhbGciOi…","token_type":"bearer"}          ← 200

$ curl localhost:8000/orders/mine
{"detail":"Not authenticated"}                               ← 401, no token

$ curl localhost:8000/orders/mine -H "Authorization: Bearer eyJhbGciOi…"
{"customer":"asha@example.com","orders":["ORD-1","ORD-3"]}   ← 200

$ curl -X POST localhost:8000/orders/ORD-1/refund -H "Authorization: Bearer <asha's token>"
{"detail":"missing permission: refunds:write"}               ← 403, authenticated but not allowed

$ curl -X POST localhost:8000/orders/ORD-1/refund -H "Authorization: Bearer <ravi's token>"
{"refunded":"ORD-1","by":"ravi@example.com"}                 ← 200

$ curl localhost:8000/orders/mine -H "Authorization: Bearer <a token that expired a minute ago>"
{"detail":"token expired"}                                   ← 401

And the timing protection from (3) in the login code, measured:

text
login for an existing email, wrong password : 45 ms
login for an email with no account          : 48 ms

Checking ownership, not just permission ​

Scopes say what kind of action a user may take. They do not say which records. "Asha may read orders" must still mean "Asha may read her orders". The most common security bug in real APIs is an endpoint like GET /orders/{order_id} that checks the user is logged in, but not that the order belongs to them, so changing the number in the URL shows a stranger's order. It is called broken object level authorisation, and it tops the OWASP list of API security risks. The fix is always in the query itself: select(Order).where(Order.id == order_id, Order.customer_id == user.id), returning 404 when nothing matches, so the endpoint does not even reveal that the order exists.

4. API keys for machines ​

A partner's warehouse system has no human to type a password. It gets a long random API key, sent in a header on every request. Treat keys like passwords: show them to the partner once, store only a hash, and let partners rotate them.

python
import hashlib
import secrets
from typing import Annotated
from fastapi import Depends, Header, HTTPException

def hash_key(raw_key: str) -> str:
    return hashlib.sha256(raw_key.encode()).hexdigest()           # (1)

new_key = "pk_live_" + secrets.token_urlsafe(32)                  # (2) shown to the partner once
PARTNER_KEYS = {hash_key(new_key): "acme-logistics"}              # only the hash is stored

def current_partner(x_api_key: Annotated[str, Header()]) -> str:
    partner = PARTNER_KEYS.get(hash_key(x_api_key))               # (3)
    if partner is None:
        raise HTTPException(status_code=401, detail="invalid API key")
    return partner

@app.get("/partners/shipments")
def shipments(partner: Annotated[str, Depends(current_partner)]):
    return {"partner": partner, "pending": 14}
  • (1) For API keys, a fast hash like SHA-256 is fine, unlike for passwords. A key made of 32 random bytes has so many possibilities that guessing is hopeless even at billions of tries per second. Slow hashing protects human-chosen passwords, which are guessable.
  • (2) secrets, never random (3.13.16). The pk_live_ prefix makes leaked keys easy to recognise and scan for in code.
  • (3) Looking up the hash means the comparison never touches the raw key. When you must compare two secret strings directly, use secrets.compare_digest, which takes the same time however many characters match, so the timing reveals nothing.

5. The mistakes that keep appearing ​

Here is a review checklist built from real incidents in FastAPI services.

  1. Secrets in code or logs. Load keys from settings with SecretStr. Never log Authorization headers, tokens, passwords or full request bodies from login endpoints.
  2. Missing ownership checks. Every query for a user's data filters by that user (section 3).
  3. Weak or unpinned JWT checks. Always pass algorithms=[...], check expiry, keep access tokens short, and use a long random secret, at least 32 bytes.
  4. Trusting client-supplied roles. A field like "is_admin": true in a request body must be impossible to set. Input models never contain it, and extra="forbid" rejects it (3.14.2).
  5. No limit on login attempts. Rate-limit the login endpoint by account and by IP address (3.14.4) and alert on spikes.
  6. Leaky errors. Different messages for "no such user" and "wrong password", or tracebacks in production responses (3.14.5).
  7. Assuming CORS is security. It protects browsers only (3.14.5). Every endpoint still needs authentication.
  8. HTTP instead of HTTPS. Bearer tokens over plain HTTP can be read by anyone on the network path. TLS terminates at the load balancer in most deployments, and 3.14.9 shows how FastAPI learns about it.

What the interviewer will push on ​

"How do you store passwords?" A slow, salted, memory-hard hash: Argon2id, or bcrypt. Never encryption, never fast hashes like SHA-256. The tell is explaining why: attackers with a leaked table can try billions of fast hashes per second, and salts stop one table cracking every user at once.

"What is a JWT, and is it encrypted?" Header, claims and signature, base64url-encoded. Signed, not encrypted, so anyone can read it and only the key holder can create a valid one. Verify with a fixed algorithm list, check exp, and put nothing secret in it.

"How do you log a user out if you use JWTs?" You cannot revoke a self-contained token, so keep access tokens short-lived, issue rotating refresh tokens stored on the server, and revoke the refresh token. Or use server-side sessions. Mention a deny list keyed by token ID for emergencies, at the cost of a lookup per request.

"401 or 403?" 401 when identity is missing or invalid. 403 when identity is known but lacks permission. Bonus: return 404 instead of 403 for other users' records, so existence is not revealed.

"How does FastAPI support scopes?" OAuth2PasswordBearer with a scopes dict, Security(dependency, scopes=[...]) on endpoints, and SecurityScopes inside the dependency to compare required scopes with the token's claims. Scopes appear in the OpenAPI document.

Something to volunteer that nobody asks for: the login endpoint should spend the same time whether or not the email exists, by verifying against a dummy hash, and return the same message. Otherwise attackers can discover which emails have accounts. The measured 45 ms against 48 ms on this page shows the fix working.

Recall

  • Authentication = who you are, failing with 401. Authorisation = what you may do, failing with 403.
  • Store passwords as slow, salted hashes: Argon2 (argon2id) through pwdlib, or bcrypt. Always verify, never compare with ==. Each hash has its own salt.
  • OAuth2 bearer tokens travel in Authorization: Bearer …. A JSON Web Token is header, claims (sub, exp, iat, scopes) and signature. It is signed, not encrypted. Always pass algorithms=[...] to block alg: none. Use HS256 for one service, RS256 or ES256 for many.
  • JWTs cannot be revoked: use short access tokens plus rotating server-side refresh tokens, or sessions with secure cookies.
  • FastAPI: OAuth2PasswordBearer, OAuth2PasswordRequestForm on /token, a get_current_user dependency that decodes, loads the user and checks scopes via SecurityScopes, and Security(..., scopes=[...]) on endpoints.
  • Prevent user enumeration with equal timing and equal messages. Prevent broken object level authorisation by filtering every query by owner and returning 404.
  • API keys: random via secrets, shown once, stored as SHA-256, compared with compare_digest when comparing raw secrets.

Self-test: Why is SHA-256 fine for API keys but not for passwords? What stops someone from editing the scopes claim in a JWT? Why must jwt.decode be given an algorithms list? Why does Asha get 403, not 401, on the refund endpoint? How would an attacker use a difference in login timing?

Quiz Bank ​

FoundationalWhy does hashing the same password twice give different stored strings, and how does verification still work?

Each hash uses a new random salt, which is mixed into the computation and stored as part of the output string, alongside the algorithm and its settings. So two hashes of the same password differ, and two users with the same password get different hashes. To verify, the library reads the salt and settings from the stored string, hashes the attempted password with exactly those, and compares the result with the stored hash in constant time. That is why you call verify(attempt, stored) instead of hashing again and comparing strings.

AppliedA security review finds that GET /orders/{order_id} returns any order to any logged-in user. Fix it properly.

Authentication is present, but object-level authorisation is missing. Change the data access, not just the endpoint: the repository method becomes get_order_for_customer(order_id, customer_id) with WHERE id = :order_id AND customer_id = :customer_id, and the endpoint passes the current user's ID from the token. Return 404 when nothing matches, so a probing user cannot even learn that the order exists. Support staff who may see any order get a separate endpoint or code path guarded by a dedicated scope. Then search the codebase for other queries by ID that lack an ownership filter, because this bug rarely appears only once.

InterviewWalk through what happens, from login to a protected request, in a FastAPI service using OAuth2 password flow with JWTs.

The client posts form fields username and password to /token. The endpoint loads the user, verifies the password against the stored Argon2 hash, spending equal time if the user does not exist, and on success creates a JWT with sub, exp, iat and the granted scopes, signed with the server's secret, returned as access_token with token_type "bearer". The client then sends Authorization: Bearer <token> on each request. For a protected endpoint, OAuth2PasswordBearer extracts the token, get_current_user verifies the signature and expiry with a fixed algorithm list, loads the user to make sure they still exist, and compares the endpoint's required scopes with the token's scopes, raising 401 or 403 as appropriate. The endpoint receives the user object and applies ownership filters to its queries.

StaffYou are moving from one monolith to twelve services that all need to know who the caller is. How do you design authentication?

Centralise login in one identity service, or an external identity provider, that issues short-lived access tokens signed with an asymmetric key, such as ES256. It publishes its public keys at a JWKS endpoint, with key IDs, so they can be rotated. Each service verifies tokens locally with the cached public keys, checking issuer, audience, expiry and algorithm, with no network call per request. Refresh tokens and sessions live only in the identity service, which also handles revocation and multi-factor login. Service-to-service calls use their own credentials, such as client-credentials tokens or mutual TLS, never forwarded user passwords. Keep authorisation decisions about specific records inside each service, because only it knows who owns its data. A shared FastAPI dependency package gives every team the same verified get_current_principal.

Next: every response so far was one JSON document sent at once. 3.14.8 covers the other shapes of traffic: streaming large responses, server-sent events for live order tracking, file uploads that never fit in memory, and WebSockets for two-way, real-time communication.

Combine chapters into one PDF

Pick the chapters you want. They print in the order you pick them.

Volume I — Technology
Part 0 — Retention & Notation
Part 1 — Foundations of Computation
Part 2 — Operating Systems
2.1 The Kernel
2.2 Processes
2.3 Threads & Scheduling
2.4 Concurrency Under the Hood
2.5 Memory Management
2.6 File Systems
2.7 Input/Output
2.8 Linux for Engineers
2.9 Windows & macOS in Practice
Part 3 — Languages, Compilers & Runtimes
3.6 JavaScript & V8
3.7 TypeScript
3.8 Node.js Internals
3.13 Python & CPython
3.14 FastAPI & Production Python
Part 4 — Data Structures & Algorithms
4.0 Classic Problems — Before NeetCode
4.4 Arrays & Hashing — Problems
4.5 Two Pointers
4.6 Sliding Window
4.8 Stack — Problems
4.9 Linked List — Problems
4.11 Binary Search — Problems
4.13 Trees
4.14 Tree — Problems
4.15 Trie — Problems
4.17 Heap — Problems
4.18 Backtracking — Problems
4.19 Graphs
4.20 Graph — Problems
4.21 Advanced Graph — Problems
4.23 1-D DP — Problems
4.24 2-D DP — Problems
4.26 Greedy — Problems
4.27 Interval — Problems
4.28 Math & Geometry — Problems
4.30 Bit Manipulation — Problems
Part 5 — Networking & the Web
5.3 IP
5.4 Transport
5.6 HTTP
Part 6 — Frontend Engineering
6.1 Browser Internals
6.2 HTML & CSS Mastery
6.3 JavaScript in the Browser
6.4 React, from First Component to Full Shop
6.5 Frameworks & Rendering
6.8 UI Engineering & Patterns
Part 7 — Databases & Storage
7.2 SQL Mastery
7.3 Storage Engine Internals
7.4 Transactions
7.5 NoSQL Taxonomy
7.8 Analytics & Big Data
Part 8 — Security, Identity & Cryptography
8.2 Cryptography
8.3 Protocols of Trust
8.4 Identity: AuthN & AuthZ
8.5 Application Security
8.6 Infrastructure Security
Part 9 — Software Design (LLD)
9.2 OOP Foundations
9.3 Design Principles
9.4 Design Patterns
9.5 Concurrency
9.6 API Design
9.7 LLD Interview Machines
9.9 Node/Express Production Playbook
Part 10 — Distributed Systems & HLD
10.7 Consistency & Consensus
10.8 Messaging & Microservices
10.14 Caching
Building blocks from the design seat
Part 11 — System Design Case Studies
Part 12 — AI & ML Engineering
12.1 What AI Engineering Is
12.2 The Math You Need
12.3 Classical Machine Learning
12.4 Data for ML
12.5 Deep Learning
12.6 Embeddings & Vector Search
12.7 Transformers & LLMs
12.8 Building with LLMs
12.9 Retrieval-Augmented Generation
12.10 Agents
12.11 Adapting Models
12.12 Production AI
12.13 Multimodal AI
12.14 AI Security & Governance
12.15 Case Studies & Capstone
Part 13 — Cloud, DevOps & Infrastructure
13.11 Git, from First Commit to Team Workflow
Part 14 — Containers: Docker & Kubernetes
14.1 Foundations
14.2 Docker
14.3 Kubernetes
14.4 Kubernetes on Azure
Part 15 — The Craft & Career
Nothing picked yet