Backend Engineer

Programming Basics

• ASCIIThe original 7-bit character set that UTF-8 is backward compatible with.
• Base CaseThe condition that stops recursion.
• Block Scope vs Function ScopeWhether a variable lives until the end of its block or of the whole function.
• BooleanA true/false value.
• Boolean Flag ArgumentsPassing true/false to switch a function's behavior, and why it hurts readability.
• Character EncodingHow characters map to bytes: ASCII, UTF-8, UTF-16.
• Code CommentText for humans in code, best used to explain why rather than what.
• Conditional (if/else)Running different code depending on a condition.
• ConstantA name bound to a value that cannot be reassigned.
• Control FlowThe order in which statements execute: branches, loops, returns.
• Data TypeThe kind of value something is, which determines what operations are valid on it.
• Default ParameterA parameter value used when the caller omits it.
• Expression vs StatementAn expression produces a value; a statement performs an action.
• FunctionA named, reusable block of code that takes inputs and returns an output.
• Global VariableA variable visible everywhere, and why it makes code hard to reason about.
• IntegerA whole-number type, usually with a fixed size and range.
• ISO 8601The standard text format for dates and times, like 2026-10-10T09:00:00Z.
• IterationStepping through the items of a collection one at a time.
• LoopRepeating code with for, while, do-while or for-each.
• Magic NumberAn unexplained literal in code that should be a named constant.
• Off-by-One ErrorA loop or index that runs one step too many or too few.
• OperatorA symbol that performs an operation on values, like +, == or &&.
• Operator PrecedenceThe rules for which operators bind first in an expression.
• Parameter vs ArgumentParameters are in the definition; arguments are the values passed at the call.
• Primitive TypeA built-in basic type such as integer, float, boolean or character.
• RecursionA function solving a problem by calling itself on smaller inputs.
• Regular ExpressionA pattern language for matching and extracting text.
• Return ValueThe result a function hands back to its caller.
• ScopeThe region of code where a name is visible.
• ShadowingAn inner variable hiding an outer one with the same name.
• Short-Circuit Evaluation&& and || stopping as soon as the result is known.
• Stack OverflowCrashing when the call stack runs out of space, usually from runaway recursion.
• StringA sequence of characters, usually immutable.
• String InterpolationEmbedding values directly inside a string literal.
• Switch / MatchChoosing between many branches based on a value.
• Ternary OperatorA compact inline if/else expression.
• Truthy and FalsyNon-boolean values that act as true or false in conditions.
• Type CoercionImplicit conversion by the language, like "5" + 1 in JavaScript.
• Type ConversionTurning a value of one type into another, explicitly or implicitly.
• UnicodeThe universal character set, and why string length is trickier than it looks.
• Unix TimestampSeconds since 1970-01-01 UTC; a simple, unambiguous point in time.
• UTF-8The dominant variable-length encoding of Unicode.
• VariableA named reference to a value stored in memory.
• Variadic FunctionA function that accepts any number of arguments.

Collections

• ArrayAn ordered, indexed collection of elements.
• DestructuringUnpacking values from arrays or objects into variables.
• Dictionary / MapA collection of key-value pairs with fast lookup by key.
• Equality vs IdentitySame value vs same object in memory.
• IndexingAccessing elements by position, usually starting at zero.
• ListAn ordered collection; a dynamic array or a linked list depending on the language.
• Map, Filter, ReduceThe three core operations for transforming collections.
• SetAn unordered collection of unique values.
• Shallow vs Deep CopyCopying only the top level vs copying everything nested inside.
• SlicingTaking a sub-range of a sequence.
• Sorting with a Key or ComparatorSorting by a custom key or comparison function.
• Spread / Rest SyntaxExpanding or collecting elements with ... (or * and ** in Python).
• TupleA fixed-size, ordered group of values, often of different types.

Object-Oriented Programming

• AbstractionExposing what something does while hiding how it does it.
• Access Modifierspublic, private and protected: who may see a member.
• ClassA blueprint for creating objects.
• ConstructorThe method that initializes a new object.
• EncapsulationHiding internal state behind a public interface.
• Field / PropertyA piece of data stored on an object.
• Getters and SettersMethods controlling access to a field.
• InheritanceA class reusing and extending another class.
• MethodA function that belongs to an object or class.
• Method OverloadingSeveral methods with the same name but different parameters.
• Method OverridingA subclass replacing a parent class's method.
• ObjectAn instance of a class holding its own state.
• Object-Oriented ProgrammingOrganizing code around objects that bundle data and behavior.
• PolymorphismOne interface with many implementations chosen at runtime.
• Static MemberA field or method that belongs to the class rather than an instance.
• this / selfThe reference to the current object inside a method.

Functional Programming

• First-Class FunctionsFunctions treated as values that can be stored, passed and returned.
• Higher-Order FunctionA function that takes or returns other functions.
• Lambda / Anonymous FunctionA function without a name, defined inline.
• Pure FunctionSame input, same output, and no side effects.
• Side EffectAnything a function does besides returning a value: I/O, mutation, logging.

Error Handling

• AssertionA check that crashes when an assumption turns out to be false.
• Custom ExceptionA domain-specific error type carrying meaningful context.
• Error HandlingAnticipating, detecting and responding to things going wrong.
• ExceptionAn object signalling an error that unwinds the call stack until caught.
• Swallowing ErrorsCatching an error and ignoring it, which hides bugs.
• Throwing / RaisingSignalling an error explicitly.
• try / catch / finallyCatching exceptions and running cleanup code regardless.

Type Systems

• EnumA type with a fixed set of named values.
• Nullable TypeA type that explicitly allows null, forcing you to handle it.
• Static vs Dynamic TypingTypes checked at compile time vs at runtime.
• Strong vs Weak TypingHow willingly a language converts between types implicitly.
• Type AliasA new name for an existing type.
• Type AnnotationExplicitly declaring the type of a variable or parameter.
• Type SystemThe rules a language uses to assign and check types.

Concurrency & Async

• CallbackA function passed in to be called when work finishes.
• Callback HellDeeply nested callbacks that make async code unreadable.

Memory & Runtime

• Compiled vs InterpretedTranslating to machine code ahead of time vs executing source at runtime.

Version Control (Git)

• Atomic CommitOne commit doing one logical thing, easy to review and revert.
• BlameSeeing who last changed each line and in which commit.
• Branch Naming ConventionsNames like feat/login-page that tell people what a branch is for.
• Conventional CommitsA commit message convention like "feat:" and "fix:" that tools can parse.
• Detached HEADChecking out a commit directly instead of a branch.
• Force PushOverwriting remote history; use --force-with-lease and never on shared branches.
• ForkYour own copy of someone else's repository, for contributing via pull requests.
• Git ConfigYour name, email, aliases and defaults, at global or repository level.
• HEADGit's pointer to the commit you currently have checked out.
• MergeCombining the histories of two branches.
• Push, Pull, FetchSending commits, downloading and merging, or only downloading.
• RemoteAnother copy of the repository, usually "origin" on GitHub or GitLab.
• RepositoryA project's files plus their complete history.
• ResetMoving a branch pointer back, in soft, mixed or hard mode.
• RevertCreating a new commit that undoes an earlier one.
• SquashCombining several commits into one.
• Staging AreaWhere you choose which changes go into the next commit.
• StashTemporarily shelving uncommitted changes.
• TagA named pointer to a commit, usually marking a release.
• Version ControlTracking every change to code so you can review, revert and collaborate.

Branching & Releases

• ChangelogA human-readable list of notable changes per release.
• Feature BranchA short-lived branch for one change.
• GitHub FlowBranch from main, open a PR, merge back to main.
• HotfixAn urgent fix shipped outside the normal release cycle.
• Protected BranchA branch that requires reviews and passing checks before merging.
• Semantic VersioningMAJOR.MINOR.PATCH, and what each number promises about compatibility.

Pull Requests & Code Review

• Approve vs Request ChangesThe review states and what each one signals.
• Draft PRA PR opened early for feedback, not yet ready to merge.
• Labels and Issue HygieneLabeling, linking and closing issues so work stays findable.
• NitsMinor, optional review comments, labeled so they don't block.
• Pair ProgrammingTwo people working on the same code at the same time.

Debugging

• BreakpointA place where the debugger pauses execution.
• Browser DevToolsThe browser's built-in tools for inspecting DOM, network, console and performance.
• Divide and Conquer DebuggingHalving the search space until the cause is isolated.
• Network TabInspecting every HTTP request a page makes.
• Print DebuggingAdding temporary output to see what code is doing.
• Step Over, Into, OutMoving through code one line or one call at a time.

Testing

• Arrange, Act, AssertThe standard three-part structure of a test.
• Flaky TestA test that passes and fails without any code change.
• Functional TestingTesting that features do what the requirements say, from the outside.
• Manual / Exploratory TestingA human exploring the product to find what automation misses.
• Smoke TestA quick check that the most basic things work after a deploy.
• Software TestingChecking code behaves as intended, automatically and repeatably.
• StubA test double that returns canned answers.
• Test AssertionThe check that decides whether a test passes.
• Test Case and Test SuiteA single scenario being checked, and a group of them run together.
• Test FixtureSetup data or state that tests rely on.
• Test IsolationTests that don't depend on each other or on shared state.

Clean Code & Principles

• Boy Scout RuleLeave the code a little cleaner than you found it.
• ConsistencyDoing similar things the same way across a codebase.
• Dead CodeCode that never runs and should be deleted.
• Deep NestingToo many levels of ifs and loops; flatten them with guard clauses.
• Long MethodA function doing too much; one of the most common smells.
• Premature OptimizationOptimizing before you know where the real bottleneck is.
• Separation of ConcernsEach part of the program handles one distinct concern.
• Structured ProgrammingBuilding programs from sequence, selection and loops instead of goto.

Refactoring

• Extract FunctionPulling a block of code into a well-named function.
• IDE Refactoring ToolsLetting the IDE perform renames and extractions safely.
• Inline Function / VariableReplacing an unnecessary indirection with its body.
• RenameChanging a name everywhere it's used, safely.

Design Patterns

• Cargo Cult ProgrammingCopying code or rituals without understanding why they work.
• MiddlewareA pipeline of functions wrapped around request handling.
• Spaghetti CodeTangled control flow that's impossible to follow.

Developer Tooling

• Build ToolAutomating compile, test and package steps, like Make, Gradle or Vite.
• curlThe command-line tool for making HTTP requests.
• DependencyExternal code your project relies on.
• Editor ShortcutsLearning your editor's shortcuts and multi-cursor editing to work faster.
• EditorConfigA shared config for indentation and line endings across editors.
• Getting Help (man, --help, tldr)Reading a command's built-in documentation.
• Go to Definition / Find ReferencesNavigating code by symbol instead of searching text.
• grep / ripgrepSearching text across files from the terminal.
• HTTP Client Toolscurl, HTTPie, Postman or Bruno for calling APIs by hand.
• IDE / Code EditorYour main tool for editing, navigating, refactoring and debugging.
• Language Version ManagerTools like nvm, pyenv or mise for switching language versions.
• PATHThe list of directories the shell searches for commands.
• Pipes and RedirectionChaining commands with a pipe and sending output to files with >.
• Pre-commit HooksRunning linters and formatters automatically before each commit.
• Regex TestersTools for building and testing regular expressions interactively.
• ShellThe program interpreting your commands: bash, zsh, fish.
• SSH KeysKey pairs for passwordless authentication to servers and Git hosts.
• Task Runner / Project ScriptsNamed project commands, like npm scripts or a justfile.
• Terminal / Command LineControlling your computer and tools through text commands.
• Terminal Text Editors (Vim, Nano)Editing files on a server where there's no IDE, and how to quit Vim.
• Virtual EnvironmentAn isolated set of packages per project, as with Python's venv.

AI-Assisted Development

• AI Coding AssistantTools like Copilot, Cursor or Claude Code that suggest and write code.
• HallucinationAn AI confidently producing APIs, facts or code that don't exist.
• Prompting for CodeGiving an AI enough context and constraints to produce useful code.
• Vibe CodingAccepting AI code without reading it: fine for prototypes, risky in production.

Documentation & Writing

• Docstrings / JSDocDocumenting functions and modules right next to the code.
• Technical WritingWriting clearly for other engineers.

Data Structures

• Binary TreeA tree where each node has at most two children.
• Data StructureA way of organizing data so certain operations are efficient.
• Dynamic ArrayAn array that grows by reallocating, with amortized O(1) appends.
• Hash FunctionA function mapping data of any size to a fixed-size value.
• Linked ListNodes pointing to the next node: fast inserts, slow random access.
• QueueA first-in, first-out collection.
• StackA last-in, first-out collection.
• TreeA hierarchy of nodes with one root and no cycles.

Algorithms

• AlgorithmA step-by-step procedure for solving a problem.
• Best, Worst and Average CaseDifferent inputs can make the same algorithm fast or slow.
• Binary SearchFinding an item in sorted data by halving the range each step.
• Brute ForceTrying every possibility; the baseline before optimizing.
• Coding Interview ProblemsAlgorithm puzzles used in hiring, and how they relate to real work.
• Common Complexity ClassesO(1), O(log n), O(n), O(n log n), O(n²), O(2ⁿ) and what they feel like in practice.
• Linear SearchChecking every element in turn.
• Sorting AlgorithmsBubble, insertion, merge, quick and heap sort, and their trade-offs.
• Space ComplexityHow memory use grows with input size.
• Time ComplexityHow the number of steps grows with input size.

Math for Programmers

• Binary and HexadecimalBase-2 and base-16 number systems.
• Bits and BytesThe basic units of data, and KB vs KiB.
• Boolean LogicAND, OR, NOT and De Morgan's laws.
• LogarithmsWhy repeatedly halving something gives O(log n).
• ModuloThe remainder after division; used for wraparound and hashing.
• Rounding and MoneyNever store money as a float; use integers or decimals.

Computer Architecture

• 32-bit vs 64-bitThe size of numbers and addresses a CPU handles natively.
• CPUThe processor that executes instructions.
• CPU CoreAn independent processing unit; modern CPUs have several.
• RAMFast, temporary memory for running programs.
• SSD vs HDDStorage types and their very different speeds.

Operating Systems

• CronScheduling commands to run at fixed times.
• Exit CodeThe number a program returns when it ends; 0 means success.
• File PermissionsRead, write and execute rights for user, group and others.
• File SystemHow files and directories are stored and organized.
• Operating SystemSoftware that manages hardware and runs programs.
• Process ID (PID)A number identifying a running process.
• stdin, stdout, stderrThe three standard streams every process starts with.
• Symbolic LinkA file that points to another path.

Compilers & Languages

• Programming ParadigmsStyles of programming: imperative, object-oriented, functional, declarative.
• Syntax vs SemanticsWhat code looks like vs what it means.

Networking Fundamentals

• Domain NameA human-readable address like example.com.
• Latency vs BandwidthHow long data takes to arrive vs how much can flow at once.
• localhost / 127.0.0.1The address that always means "this machine".
• ping and tracerouteChecking reachability and the path packets take.

HTTP

• 2xx Success Codes200 OK, 201 Created, 204 No Content and friends.
• 3xx Redirects301, 302, 307, 308 and when to use each one.
• 4xx Client Errors400, 404, 409, 422, 429: the client did something wrong.
• 5xx Server Errors500, 502, 503, 504: the server failed.
• Content-TypeThe header declaring a body's format, like application/json.
• HTTP RequestA method, URL, headers and an optional body.
• HTTP ResponseA status code, headers and a body.
• Query StringKey-value parameters after the ? in a URL.
• RedirectSending a client to a different URL.
• URL EncodingEscaping special characters in URLs as %XX.
• User-AgentThe header identifying the client software.
• WebhookAn HTTP callback: a service calls your URL when something happens.

TLS & Certificates

• Let's EncryptA free, automated certificate authority.
• TLS CertificateA file proving a server controls a domain, signed by a trusted authority.

API Styles & Formats

• APIAn interface that lets programs talk to each other.
• Resource NamingPlural nouns, nested paths and consistent URL design.
• SerializationConverting objects to bytes or text for storage or transfer.
• YAMLA human-friendly data format common in configuration files.

How Browsers Work

• Web BrowserThe program that fetches, renders and runs web pages.

Real-Time Communication

• PollingAsking the server repeatedly whether something changed.

HTML

• AttributeExtra information on an element, like href or alt.
• Element and TagThe building blocks of HTML, like <p> and <a>.
• Form ValidationChecking input in the browser and, always, again on the server.
• FormsInputs, labels, validation and submission.
• Head and Meta TagsTitle, description, viewport and other page metadata.
• HTMLThe markup language that structures web pages.
• HTML EntitiesEscaped characters like &amp; and &lt;.
• Semantic HTMLUsing elements for their meaning, like <nav>, <main> and <button>.

CSS

• CSSThe language that styles web pages.

JavaScript & TypeScript

• == vs ===Loose equality with coercion vs strict equality.
• ES Modulesimport and export: JavaScript's standard module system.
• Fetch APIThe built-in way to make HTTP requests from JavaScript.
• JavaScriptThe programming language of the web.
• JSON.parse and JSON.stringifyConverting between JSON text and JavaScript values.
• Node.jsA JavaScript runtime for servers and tooling.
• Optional Chaining and Nullish Coalescing?. and ?? for handling missing values safely.
• Template LiteralsBacktick strings with interpolation.
• TypeScriptJavaScript with static types.
• var, let and constJavaScript's three ways to declare variables, and how they're scoped.

State Management & Data Fetching

• Single Source of TruthEach piece of data has exactly one authoritative owner.

Rendering Strategies

• Client-Side Rendering (CSR)The browser builds the page with JavaScript.
• Multi-Page Application (MPA)Traditional sites where each page is a full load.
• Server-Side TemplatesHTML generated by templates like Jinja, ERB or Thymeleaf.
• Single-Page Application (SPA)One HTML page whose content changes through JavaScript.
• sitemap.xml and robots.txtTelling crawlers what to index and what to skip.
• Static Site Generation (SSG)Building HTML once, at build time.

Accessibility

• Accessibility (a11y)Making software usable by people with disabilities.

Frontend Build Tooling

• Dev ServerA local server that rebuilds as you edit.
• node_modulesWhere installed packages live, and why it gets so big.
• npm ScriptsProject commands defined in package.json.
• package.jsonThe manifest of a JavaScript project: its dependencies and scripts.
• Source MapA mapping from built code back to the original source, for debugging.
• Static AssetsImages, fonts and files served as-is.

Backend Basics

• BackendThe server side: business logic, data and integrations.
• Business LogicThe rules that make your product what it is.
• File UploadsAccepting, validating and storing files from users.
• Filtering and SortingLetting clients narrow down and order results.
• Health CheckAn endpoint reporting whether the service is alive and ready.
• MVCModel-View-Controller: separating data, presentation and input handling.
• Request Handler / ControllerThe code that processes a single request.
• Request LifecycleWhat happens between a request arriving and a response leaving.
• Scheduled JobsTasks that run on a schedule, like nightly cleanups.
• Sending EmailTransactional email through a provider, and deliverability basics.
• Web ServerSoftware that accepts HTTP requests and returns responses.
• Web Servers (Nginx, Apache, Caddy)The common servers that sit in front of applications.

API Design

• 429 Too Many RequestsThe status returned when a client goes over a rate limit.
• API Naming ConventionsConsistent casing, plurals and verbs across endpoints.
• Breaking ChangeA change that forces clients to update.

Relational Databases & SQL

• Audit Columns (created_at, updated_at)Recording when, and by whom, rows changed.
• CASE ExpressionConditional logic inside a SQL query.
• COALESCE and NULLIFHandling NULLs inside SQL expressions.
• ConstraintsDatabase rules like NOT NULL, UNIQUE and CHECK.
• CRUDCreate, Read, Update, Delete: the four basic data operations.
• DatabaseOrganized, persistent storage for data.
• Database Client / GUITools like psql, DBeaver or TablePlus for exploring databases.
• Database SchemaThe structure of tables, columns and relationships.
• DDL, DML, DCL and DQLSQL's categories: defining structure, changing data, granting access, querying.
• GROUP BY and AggregatesSummarizing rows with COUNT, SUM and AVG.
• HAVINGFiltering groups after aggregation.
• INNER, LEFT, RIGHT and FULL JOINWhich rows each kind of join keeps.
• Junction TableA table linking two others in a many-to-many relationship.
• NULL in SQLThree-valued logic, and why NULL = NULL isn't true.
• One-to-Many and Many-to-ManyThe basic kinds of relationship and how to model them.
• PostgreSQL, MySQL and SQLiteThe common relational databases and where each one fits.
• Relational DatabaseData stored in tables with rows, columns and relationships.
• SQL Data TypesChoosing integer, numeric, text, timestamp and other column types.
• SQL String, Date and Math FunctionsBuilt-in functions for transforming values in queries.
• Table, Row, ColumnThe basic structure of relational data.
• UNION, INTERSECT, EXCEPTCombining the results of several queries.

NoSQL & Other Data Stores

• Document DatabaseStoring JSON-like documents, as in MongoDB.
• Key-Value StoreStoring values by key, as in Redis or DynamoDB.
• NoSQLDatabases not built on the relational table model.
• Object StorageStoring files as objects, as in S3.
• RedisAn in-memory data store used for caching, queues and more.

Schema Migrations

• Migration ToolsTools like Flyway, Alembic, Prisma Migrate and Rails migrations.
• Seed DataInitial data loaded for development or tests.

Caching

• Cache Hit and MissWhether the requested data was found in the cache.
• TTL (Time to Live)How long a cached item stays valid.

Queues & Async Processing

• MessageA self-contained unit of data sent from one component to another through a broker.

Email & Notifications

• Transactional vs Marketing EmailPassword resets vs newsletters, and why they're sent separately.

Files & Media

• CSV Import / ExportMoving tabular data in and out, with all its edge cases.
• File StorageWhere uploaded files live: local disk, object storage or a CDN.
• MIME TypeThe standard label for a file's format, like image/png.

Product Building Blocks

• Sign-Up and Email VerificationCreating accounts and confirming the user owns the email address.
• Slugs and Readable URLsTurning titles into URL-safe identifiers, and handling duplicates and renames.

Architecture Styles

• Client-Server ModelClients make requests; servers respond.
• MonolithOne deployable application containing all the features.

System Design Fundamentals

• CDNA network of edge servers serving content close to users.
• Load BalancerDistributing traffic across servers.
• Static Content HostingServing files straight from storage or a CDN instead of your app.
• Vertical ScalingScaling up with a bigger machine.

Reliability & Resilience

• BackupsCopies of data for restoring, and why untested backups don't count.

Performance & Scalability

• LatencyThe time a single operation takes.

Authentication & Authorization

• API KeyA long random secret identifying a calling application rather than a user.
• Basic AuthenticationSending a username and password with every request, Base64-encoded.
• bcryptA widely supported password hashing algorithm with a tunable cost factor.
• Bearer TokenA token that grants access to whoever presents it, sent in the Authorization header.
• CookieA small piece of data the server asks the browser to store and send back automatically on later requests.
• CredentialAnything used to prove identity: a password, key, token or certificate.
• JWT (JSON Web Token)A signed, self-contained token carrying claims like user ID and expiry, verifiable without a database lookup.
• SaltA random value added to each password before hashing so identical passwords get different hashes.

Web Application Security

• Input SanitizationCleaning untrusted input, and why validation and escaping matter more.
• Output Encoding / EscapingEscaping data for the context it's inserted into.
• Parameterized QueryPassing values separately from SQL so they can't change its meaning.

Cryptography Basics

• Base64An encoding of bytes as text; not encryption.
• Don't Roll Your Own CryptoUse vetted libraries; homemade cryptography is almost always broken.
• Encryption in TransitEncrypting data as it travels, with TLS.
• Hashing vs Encryption vs EncodingA one-way fingerprint vs reversible with a key vs just a different format.

Secure Development

• Phishing and Social EngineeringAttacks that trick people instead of breaking code.

Privacy & Compliance

• PIIPersonally identifiable information that needs special care.

Linux & Servers

• Archiving and Compression (tar, gzip, zip)Bundling and compressing files.
• Copying Files Remotely (scp, rsync)Moving files between machines.
• Disk Space (df, du)Finding what's filling up the disk.
• LinuxThe operating system most servers run.
• Linux Directory StructureWhat /etc, /var, /usr, /home and /tmp are for.
• Managing Processes (ps, top, kill)Seeing and controlling running programs.
• OS Package Managers (apt, dnf, brew)Installing system software.
• sudo and rootRunning commands with administrator privileges.
• Virtual MachineA fully emulated computer running on shared hardware.

Containers

• ContainerA lightweight, isolated package of an app and its dependencies.
• Container LogsReading a container's stdout and stderr.
• Container RegistryWhere images are stored and pulled from.
• Container vs Virtual MachineSharing the host kernel vs emulating a full machine.
• Docker ComposeRunning multi-container setups from one YAML file.
• DockerfileThe recipe for building an image.
• Ephemeral Container FilesystemAnything written inside a container disappears when it's removed.
• ImageA read-only template that containers are created from.
• Port MappingExposing a container's port on the host.
• VolumePersistent storage that outlives a container.

Cloud Computing

• AWS, GCP and AzureThe three biggest cloud providers.
• Cloud ComputingRenting computing resources on demand.
• Compute Instance (EC2)A virtual server in the cloud.
• IaaS, PaaS, SaaSHow much of the stack the provider manages for you.
• Managed DatabaseA database the cloud provider runs for you.
• Platforms (Vercel, Netlify, Render, Fly)Hosts that deploy straight from Git with little setup.
• S3 / Blob StorageCheap, durable object storage.
• ServerA machine, or a program on one, that provides a service to clients.

CI/CD & Deployment

• Build ArtifactThe packaged output of a build, deployed as-is.
• CI PipelineThe sequence of automated build, test and deploy steps.
• GitHub ActionsGitHub's built-in CI/CD.
• Staging EnvironmentA production-like environment for final testing.

Observability

• DashboardA visual display of key metrics.
• MonitoringWatching known metrics and alerting when they go wrong.
• Uptime MonitoringChecking from the outside that a site responds.

Data Engineering Foundations

• Data Engineer vs Analyst vs Scientist vs ML EngineerWho builds pipelines, who answers questions, who models, and who ships models.
• DatasetA named collection of related data, like a table or a set of files.
• Structured, Semi-Structured and Unstructured DataTables, JSON-like records, and free-form text, images or audio.

Collection & Instrumentation

• Event Naming ConventionsConsistent names like order_completed so events are findable and comparable.
• InstrumentationAdding code that records what users and systems do, so the data exists at all.

Storage, Formats & Lakehouse

• CSVThe simplest tabular format, and its quoting, encoding and type pitfalls.

Stream Processing

• Real-Time vs Near-Real-TimeMilliseconds vs minutes, and which one the business actually needs.

LLM & AI Engineering

• Large Language ModelA model trained on huge amounts of text to understand and generate language.

Agile & Delivery Process

• AgileDelivering in small increments and adapting to feedback.
• BacklogThe prioritized list of work that hasn't started yet.
• Backlog RefinementClarifying and sizing upcoming work.
• Daily StandupA short daily sync on progress and blockers.
• EpicA large body of work split into smaller stories.
• KanbanVisualizing work on a board and limiting work in progress.
• RetrospectiveA regular meeting to reflect on how the team works and improve it.
• ScrumAn agile framework with sprints, roles and ceremonies.
• Software Development LifecycleThe stages from idea to production to maintenance.
• SprintA fixed period, often two weeks, to deliver planned work.
• Sprint PlanningChoosing the work for the next sprint.
• Sprint Review / DemoShowing what was built to stakeholders.
• User Story"As a user, I want… so that…": a requirement from the user's point of view.
• WaterfallSequential phases from requirements to release.

Estimation & Planning

• Planning PokerEstimating as a team by revealing guesses at the same time.
• Story PointsRelative effort estimates instead of hours.
• TimeboxingFixing the time and adjusting the scope.

Communication

• 1:1 MeetingsRegular private conversations with your manager.
• Giving a DemoShowing your work clearly to an audience.
• Receiving FeedbackListening, asking for specifics, and acting on it.
• Working with QACollaborating with testers to ship quality.
• Writing ClearlyLead with the point, be specific, keep it short.

Product Thinking

• Edge CasesUnusual inputs and situations that break naive code.
• RequirementsWhat the software must do.
• User EmpathyRemembering a real person uses what you build.

Junior Habits & First Job

• Context Switching CostWhy jumping between tasks destroys productivity.
• Deep Work / Focus TimeLong, uninterrupted blocks for hard problems.
• Done Is Better Than PerfectShipping working software instead of polishing forever.
• Finding a MentorGetting guidance from someone more experienced.
• Fundamentals over FrameworksFrameworks change; the concepts underneath them don't.
• Impostor SyndromeFeeling you don't belong despite the evidence.
• Keeping an Engineering JournalWriting down what you learn, decide and get stuck on.
• Learning How to LearnDeliberate practice, spaced repetition and building things.
• Onboarding YourselfUsing code, docs and history to learn a new codebase.
• Time ManagementPlanning your day, protecting focus time and finishing what you start.
• Tutorial HellEndlessly following tutorials without building anything on your own.

Career Growth

• Behavioral Interview (STAR)Answering with Situation, Task, Action and Result.
• BurnoutChronic work stress, and how to notice and prevent it.
• Career LadderThe levels and expectations from junior to principal.
• Contributing to Open SourceFinding issues, following the guidelines and opening PRs.
• Job SearchResumes, portfolios, applications and referrals.
• Junior EngineerLearning to deliver well-defined tasks with guidance.
• Performance ReviewA periodic assessment of your work.
• Side ProjectsBuilding outside work to learn and to show your skills.
• Sustainable PaceWorking at a pace you can keep up for years.
• Technical InterviewsCoding, system design and behavioral rounds.

Programming Basics

• Bitwise OperationOperating on individual bits: AND, OR, XOR and shifts.
• Integer OverflowA value exceeding its type's range and wrapping around or failing.
• Pattern MatchingBranching on the shape of data and destructuring it at the same time.
• Tail RecursionRecursion where the call is the last action, which some languages turn into a loop.

Collections

• GeneratorA function that lazily yields a sequence of values.
• IteratorAn object that yields items one at a time from a sequence.
• Lazy EvaluationComputing values only when they're actually needed.

Object-Oriented Programming

• Abstract ClassA class that can't be instantiated and leaves some methods to subclasses.
• InterfaceA contract of methods a type promises to implement.
• Mixin / TraitReusable behavior added to classes without inheritance.
• Special MethodsMethods the language calls implicitly, like __eq__ or toString.

Functional Programming

• ClosureA function that remembers variables from the place it was defined.
• Declarative vs ImperativeDescribing what you want vs spelling out how to do it.
• Function CompositionCombining functions so the output of one feeds the next.
• Functional ProgrammingBuilding programs from pure functions and immutable data.
• ImmutabilityNever changing data after creation, producing new values instead.
• MemoizationCaching a function's results for inputs it has already seen.
• Option / Maybe TypeA type that explicitly represents "a value or nothing".
• Partial ApplicationFixing some arguments of a function to get a new function.
• Result / Either TypeA type that represents success or failure without exceptions.

Error Handling

• Checked vs Unchecked ExceptionsWhether the compiler forces you to handle an exception.
• Defensive ProgrammingWriting code that guards against invalid inputs and states.
• Error Values vs ExceptionsReturning errors as values vs throwing them.
• Fail FastStopping loudly on problems instead of continuing in a bad state.
• PanicAn unrecoverable error that aborts the program or thread.

Type Systems

• Discriminated UnionA union whose members are told apart by a tag field.
• Duck TypingIf it has the right methods, it's the right type.
• Finite State MachineA model with a fixed set of states and allowed transitions, e.g. an order going from paid to shipped.
• GenericsCode that works over many types while keeping type safety.
• Runtime ValidationChecking that untrusted data matches a type at runtime, e.g. with Zod or Pydantic.
• Type InferenceThe compiler working out types without annotations.
• Type NarrowingRefining a broad type to a specific one through checks.
• Union TypeA value that can be one of several types.

Concurrency & Async

• Atomic OperationAn operation that completes entirely or not at all, with no interleaving.
• Blocking vs Non-blocking I/OWhether waiting for I/O stops the thread.
• CancellationStopping in-flight async work cleanly, e.g. with AbortController or a context.
• Check-Then-Act Race (TOCTOU)Checking a condition and acting on it as two steps, so something changes in between.
• CoroutineA function that can pause and resume; the basis of async/await.
• Critical SectionCode that must not run concurrently with itself.
• DeadlockTwo or more tasks waiting on each other forever.
• Global Interpreter Lock (GIL)Python's lock that lets only one thread run bytecode at a time.
• Mutex / LockEnsuring only one thread enters a critical section at a time.
• ProcessA running program with its own memory space.
• ThreadAn execution path within a process that shares its memory.
• Thread PoolA fixed set of reusable worker threads.
• Thread SafetyCode that behaves correctly when called from many threads.

Memory & Runtime

• BytecodeAn intermediate instruction format run by a virtual machine.
• Garbage CollectionAutomatic reclamation of memory that's no longer reachable.
• Language Runtime / VMThe environment that executes your code: JVM, V8, CPython, CLR.
• Memory LeakMemory that's never released, growing until the program slows or crashes.
• PointerA variable that holds a memory address.
• Stack vs HeapShort-lived call frames vs dynamically allocated, longer-lived memory.

Version Control (Git)

• Cherry-PickApplying one specific commit onto another branch.
• Fast-Forward vs Merge CommitMoving a branch pointer ahead vs recording a merge commit.
• Git HooksScripts that run on Git events, like linting before a commit.
• Git LFSStoring large binary files outside normal Git history.
• MonorepoMany projects living in one repository.
• ReflogGit's log of where HEAD has been; your undo history after disasters.
• Removing Secrets from Git HistoryPurging a committed secret with git filter-repo, and why you must rotate it anyway.
• Rewriting Shared HistoryWhy rebasing or force-pushing shared branches breaks teammates.
• Signed CommitsCryptographically proving who authored a commit.
• SubmoduleA repository embedded inside another at a fixed commit.

Branching & Releases

• Branching StrategyThe team's rules for how branches are created and merged.
• Git FlowA model with develop, feature, release and hotfix branches.
• Long-Lived BranchA branch kept for weeks, and the painful merges that follow.
• Release BranchA branch stabilized for shipping a specific version.
• Release NotesA user-facing explanation of what changed in a release.
• Trunk-Based DevelopmentEveryone merges small changes to main frequently.

Pull Requests & Code Review

• AI-Assisted Code ReviewUsing AI reviewers as a first pass, not a replacement for human review.
• CODEOWNERSA file that assigns required reviewers by path.
• CONTRIBUTING GuideA file explaining how to propose changes to a project.
• Merge Commit vs Squash vs Rebase MergeHow a PR lands on main and what history it leaves behind.
• Mob ProgrammingA whole team working on one problem together.
• Review TurnaroundHow quickly reviews happen, and why it matters to team speed.

Debugging

• Conditional BreakpointPausing only when a condition is true.
• Five WhysAsking "why" repeatedly to get from a symptom to its root cause.
• HeisenbugA bug that disappears when you try to observe it.
• ProfilerA tool that measures where time or memory goes.
• Remote DebuggingAttaching a debugger to code running somewhere else.

Testing

• Acceptance TestVerifying a feature meets the agreed requirements.
• Behavior-Driven DevelopmentSpecifying behavior as plain-language scenarios shared with non-developers.
• Deterministic TestsControlling time, randomness and network so tests always behave the same.
• FakeA working but simplified implementation, like an in-memory database.
• Given / When / ThenDescribing tests as context, action and expected outcome.
• Load TestingMeasuring behavior under expected traffic.
• Mock ServerA fake API that returns canned responses, for testing clients in isolation.
• Over-MockingMocking so much that tests check implementation instead of behavior.
• Performance TestingMeasuring speed and resource use; load, stress, soak and spike tests.
• Red, Green, RefactorThe three-step TDD cycle.
• Snapshot TestComparing output to a saved snapshot.
• SpyA test double that records calls to a real or fake function.
• Test Data Builder / FactoryHelpers that create valid test objects with sensible defaults.
• Test DatabasesUsing a real, isolated database in tests and resetting it between runs.
• TestcontainersSpinning up real databases and services in Docker for tests.

Clean Code & Principles

• Broken Windows TheorySmall neglected messes invite bigger ones.
• Chesterton's FenceDon't remove something until you know why it was put there.
• Command-Query SeparationA method should either change state or return data, not both.
• Convention over ConfigurationSensible defaults so you only configure what's unusual.
• Cyclomatic ComplexityA count of independent paths through code; a rough complexity measure.
• Dependency Inversion Principle (D)Depend on abstractions, not concrete implementations.
• Encapsulate What VariesIsolating the parts that change from the parts that stay the same.
• Feature EnvyA method more interested in another class's data than its own.
• God ObjectA class that knows and does too much.
• IdempotenceDoing something twice has the same effect as doing it once.
• Interface Segregation Principle (I)Clients shouldn't depend on methods they don't use.
• Law of DemeterOnly talk to your immediate neighbors; avoid a.b().c().d().
• Liskov Substitution Principle (L)Subtypes must work anywhere their parent type is expected.
• Open/Closed Principle (O)Open for extension, closed for modification.
• Premature AbstractionGeneralizing before you have enough examples, creating the wrong abstraction.
• Primitive ObsessionUsing raw strings and ints where a small domain type belongs.
• Principle of Least AstonishmentCode and APIs should behave the way people expect.
• Program to an InterfaceDepending on what something does rather than which class it is.
• Rule of ThreeTolerating duplication until the third time, to avoid the wrong abstraction.
• Shotgun SurgeryOne change requiring edits in many scattered places.
• Tell, Don't AskTell objects what to do instead of querying their state and deciding for them.

Refactoring

• Characterization TestA test that captures current behavior before you change legacy code.
• Extract ClassSplitting a class that does too much.
• Introduce Parameter ObjectGrouping parameters that travel together into one object.
• Legacy CodeCode without tests that you're afraid to change.
• Replace Conditional with PolymorphismSwapping a type switch for subclasses or strategies.

Design Patterns

• Active RecordObjects that know how to save themselves to the database.
• AdapterWrapping an interface to make it match another.
• Anti-PatternA common solution that looks right but causes problems.
• BuilderConstructing complex objects step by step.
• Chain of ResponsibilityPassing a request along handlers until one deals with it; how middleware works.
• CommandTurning a request into an object you can queue, log or undo.
• CompositeTreating individual objects and groups of them uniformly, as a tree.
• DecoratorAdding behavior to an object by wrapping it.
• Design PatternA named, reusable solution to a recurring design problem.
• FacadeA simple interface over a complex subsystem.
• Factory MethodLetting subclasses or functions decide which class to instantiate.
• Gang of FourThe 1994 book that catalogued 23 classic patterns.
• Inversion of ControlA framework calls your code rather than your code calling it.
• Iterator PatternTraversing a collection without exposing its internals.
• Null ObjectA do-nothing object used instead of null checks.
• ObserverNotifying subscribers when something changes.
• ProxyA stand-in that controls access to another object.
• Publish-SubscribeSenders publish to topics; receivers subscribe without knowing each other.
• Repository PatternA collection-like interface over data storage.
• SingletonEnsuring a class has exactly one instance; often an anti-pattern.
• StateChanging an object's behavior when its internal state changes.
• StrategySwapping algorithms behind a common interface.
• Template MethodA base algorithm whose steps subclasses fill in.
• Transaction ScriptOrganizing business logic as one procedure per request.

Developer Tooling

• Code GenerationGenerating boilerplate from schemas or templates.
• Dependency HellConflicting version requirements that can't all be satisfied.
• Dev ContainersA reproducible development environment defined as a container.
• DotfilesYour personal config files, often kept in Git.
• jqA command-line JSON processor.
• Language Server ProtocolThe protocol that gives editors autocomplete and diagnostics for any language.
• MakefileA classic way to define project tasks and their dependencies.
• Reading Library Source CodeReading a library's code when its docs don't answer your question.
• Shell ScriptingAutomating tasks with shell scripts.
• Static AnalysisFinding bugs by analyzing code without running it.
• Transitive DependencyA dependency of one of your dependencies.

AI-Assisted Development

• Agent Instruction FilesRepository files like CLAUDE.md or AGENTS.md that tell AI agents the project's conventions.
• Coding AgentAn AI that plans, edits across files and runs commands on its own.
• Context WindowHow much text a model can consider at once.
• Model Context Protocol (MCP)A standard for connecting AI assistants to tools and data.

Documentation & Writing

• API DocumentationReference docs for an API's endpoints, parameters and errors.
• Architecture DiagramA box-and-arrow picture of a system's components and data flow.
• Class DiagramA diagram of classes, their fields and relationships.
• Diagrams as CodeWriting diagrams as text, with tools like Mermaid or PlantUML.
• Docs as CodeKeeping docs in the repository and reviewing them like code.
• Onboarding DocumentationDocs that get a new teammate productive quickly.
• RunbookStep-by-step instructions for operating or fixing a system.
• Sequence DiagramA diagram of messages passed between components over time.
• State DiagramA diagram of states and the transitions between them.
• UMLA standard visual language for software diagrams.

Data Structures

• Adjacency List vs MatrixTwo ways to store a graph's edges.
• B-TreeA wide, shallow tree optimized for disks; how database indexes work.
• Binary Search TreeA binary tree ordered so each lookup can halve the search.
• DequeA double-ended queue that adds and removes at both ends.
• Directed Acyclic Graph (DAG)A graph with directed edges and no cycles, as in build systems and pipelines.
• Doubly Linked ListA linked list with pointers in both directions.
• GraphNodes connected by edges; models networks, dependencies and maps.
• Hash CollisionTwo keys hashing to the same slot, and how tables handle it.
• HeapA tree that keeps the min or max at the root; backs priority queues.
• LRU CacheA cache evicting the least recently used item, built from a hash map and a linked list.
• Priority QueueA queue that always returns the highest-priority item first.
• Tree TraversalVisiting tree nodes in pre-order, in-order, post-order or level order.
• TrieA tree of characters for fast prefix lookups.

Algorithms

• Amortized AnalysisThe average cost per operation over a sequence of operations.
• BacktrackingTrying choices and undoing them when they lead nowhere.
• Big Omega and Big ThetaLower bounds and tight bounds, alongside Big O's upper bound.
• Breadth-First SearchExploring a graph level by level; finds shortest unweighted paths.
• Depth-First SearchExploring a graph as deep as possible before backtracking.
• Divide and ConquerSplitting a problem into smaller ones and combining the results.
• Dynamic ProgrammingSolving overlapping subproblems once and reusing the answers.
• Greedy AlgorithmTaking the locally best choice at each step.
• Merge SortSplit in half, sort each half, merge: a stable O(n log n) sort.
• QuicksortPartitioning around a pivot; fast in practice, O(n²) in the worst case.
• Sliding WindowMaintaining a moving range over a sequence.
• Stable SortA sort that keeps equal elements in their original order.
• Topological SortOrdering tasks so every dependency comes first.
• Two PointersWalking two indexes through data to avoid nested loops.

Math for Programmers

• CombinatoricsCounting arrangements and combinations, e.g. how many IDs a format allows.
• Discrete MathLogic, sets, graphs and combinatorics: the math of computing.
• Percentiles (p50, p95, p99)The value below which a given share of measurements fall; the right way to read latency.
• Probability BasicsReasoning about chance, for sampling, A/B tests and failure rates.
• Set TheoryUnions, intersections and differences; the basis of SQL.
• Statistics for EngineersMean, median, percentiles and variance.

Computer Architecture

• CPU CacheSmall, very fast memory close to the CPU (L1, L2, L3).
• GPUA processor for massively parallel work like graphics and ML.
• How a CPU Executes ProgramsFetch, decode, execute: how instructions actually run.
• Instruction Set (x86, ARM)The machine instructions a CPU family understands.
• Latency Numbers Every Programmer Should KnowRough costs of cache, memory, disk and network access.

Operating Systems

• Daemon / ServiceA background process, usually managed by systemd.
• File DescriptorA handle to an open file, socket or pipe.
• Graceful ShutdownFinishing in-flight work before exiting on SIGTERM.
• KernelThe core of the OS with full access to the hardware.
• Out of Memory (OOM)Running out of memory, and the OOM killer that ends processes.
• Process LifecycleHow processes are created, run, wait and exit.
• Resource Limits (ulimit)Per-process caps on open files, memory and processes.
• SignalsMessages like SIGTERM and SIGKILL sent to processes.
• System CallA program asking the kernel to do something, like read a file.
• Virtual MemoryEach process sees its own address space, mapped onto physical memory.

Compilers & Languages

• Abstract Syntax Tree (AST)A tree of code's structure that linters, formatters and compilers work on.
• CompilerA program that translates source code into another form.
• Decorators / AnnotationsSyntax for attaching behavior or metadata to functions and classes.
• InterpreterA program that executes source code directly.
• ParserTurning text into a structured representation.
• ReflectionA program inspecting its own structure at runtime.
• TranspilerA compiler from one high-level language to another, like TypeScript to JavaScript.

Networking Fundamentals

• Connect Timeout vs Read TimeoutWaiting to establish a connection vs waiting for data on it.
• Connection PoolingReusing a set of open connections instead of opening new ones.
• DHCPHow devices get an IP address automatically when they join a network.
• DNS Record TypesA, AAAA, CNAME, MX, TXT, NS and what each one does.
• DNS TTL and PropagationHow long DNS answers are cached, and why changes take time to spread.
• FirewallRules that allow or block network traffic.
• FTP and SFTPOlder file transfer protocols, and the SSH-based secure version.
• ICMPThe protocol behind ping and many network error messages.
• Inspecting Connections (ss, netstat, lsof)Seeing which ports and connections a machine has open.
• IPv4 vs IPv632-bit vs 128-bit addresses, and why IPv6 exists.
• Keep-Alive ConnectionsReusing one connection for many requests.
• NATMany private addresses sharing one public IP.
• OSI ModelA seven-layer model of how network communication is structured.
• PacketA unit of data sent over a network.
• Private IP RangesAddress blocks reserved for internal networks.
• Round-Trip Time (RTT)The time for a message to go out and a reply to come back.
• SocketAn endpoint for sending and receiving data over a network.
• Subnet and CIDRDividing IP ranges, written like 10.0.0.0/16.
• TCPReliable, ordered, connection-based transport.
• TCP Three-Way HandshakeSYN, SYN-ACK, ACK: how a TCP connection starts.
• TCP/IP ModelThe practical four-layer model the internet actually runs on.
• ThroughputHow much work or data gets through per unit of time.
• UDPFast, connectionless transport with no delivery guarantees.
• VPNAn encrypted tunnel into another network.

HTTP

• Cache-ControlThe header that directs how responses may be cached.
• Content NegotiationClient and server agreeing on format and language through Accept headers.
• ETagA version identifier used for conditional requests and caching.
• HSTSA header telling browsers to always use HTTPS for a site.
• HTTP Compressiongzip and Brotli shrinking responses on the wire.
• HTTP ProxyAn intermediary that forwards HTTP requests.
• HTTP/1.1The text-based HTTP version with one request at a time per connection.
• HTTP/2Binary framing and many requests multiplexed over one connection.
• Long PollingHolding a request open until the server has news.
• multipart/form-dataThe encoding used to upload files from forms.
• OriginScheme + host + port: the browser's security boundary.
• Preflight RequestThe OPTIONS request a browser sends before certain cross-origin calls.
• Safe and Idempotent MethodsWhich HTTP methods shouldn't change state, and which can be retried safely.
• Same-Origin PolicyThe browser rule that isolates content from different origins.
• Server-Sent EventsA one-way stream of events from server to browser over HTTP.
• Synchronous vs Asynchronous APIsReturning the result in the response vs accepting work and reporting later.
• Webhooks vs PollingBeing notified when something changes vs repeatedly asking.
• WebSocketA persistent, two-way connection between browser and server.

TLS & Certificates

• Certificate AuthorityAn organization trusted to sign certificates.
• Certificate ExpiryExpired certificates as a classic cause of outages, and automating renewal.
• Self-Signed CertificateA certificate not signed by a trusted authority, used in development.
• TLS TerminationDecrypting TLS at a load balancer or proxy in front of your app.

API Styles & Formats

• API Client / SDKA library wrapping an API so callers don't hand-write HTTP.
• GraphQLA query language that lets clients ask for exactly the data they need.
• GraphQL Schema and ResolversTypes describing the data, and functions that fetch each field.
• gRPCA fast RPC framework built on HTTP/2 and Protocol Buffers.
• JSON SchemaA vocabulary for validating the structure of JSON.
• OpenAPIA standard format for describing REST APIs.
• Protocol BuffersA compact, schema-based binary serialization format.
• Resource ModelingDeciding what your API's resources are and how they relate.
• REST ConstraintsStatelessness, uniform interface, cacheability and REST's other rules.
• RPCCalling a function on another machine as if it were local.
• XMLA verbose markup format still common in enterprise and legacy systems.

How Browsers Work

• Browser CacheThe browser storing responses so it doesn't download them again.
• Browser StorageCookies, localStorage, sessionStorage and IndexedDB.
• Critical Rendering PathThe steps from HTML bytes to pixels on screen.
• JavaScript EngineThe component that runs JavaScript, like V8 or SpiderMonkey.

Real-Time Communication

• Real-Time CommunicationPushing updates to clients as they happen.
• Real-Time Pub/SubBroadcasting events to subscribed clients through a broker.

JavaScript & TypeScript

• CommonJSNode's older require/module.exports module system.
• Deno and BunNewer JavaScript runtimes with built-in tooling.
• ECMAScriptThe standard JavaScript implements, with a new version every year.
• Microtasks vs MacrotasksWhy promise callbacks run before setTimeout callbacks.

State Management & Data Fetching

• Stale-While-RevalidateShowing cached data immediately while fetching fresh data in the background.

Rendering Strategies

• Canonical URLTelling search engines which URL is the original.
• Hypermedia-Driven Apps (htmx)Swapping server-rendered HTML fragments instead of building a SPA.
• Rendering StrategiesWhere and when HTML gets generated.
• SEOMaking pages discoverable and well ranked by search engines.
• Server-Side Rendering (SSR)The server builds HTML for each request.

Web Performance

• Synthetic MonitoringMeasuring with scripted visits from controlled locations.
• Time to First Byte (TTFB)How long until the first byte of the response arrives.
• Web PerformanceHow fast pages load and respond.

Frontend Build Tooling

• Asset FingerprintingContent hashes in file names so caches update correctly.
• Keeping Dependencies UpdatedUpgrading regularly, with tools like Dependabot or Renovate.
• npm vs pnpm vs YarnJavaScript package managers and their trade-offs.
• Peer DependencyA dependency the host project must provide, like React for a component library.

UI/UX for Engineers

• A/B TestingComparing two variants with real users to see which performs better.
• Dark PatternsDeceptive UI that tricks users, and why to refuse to build it.
• Error MessagesMessages that say what went wrong and how to fix it.
• Internationalization (i18n)Preparing software for many languages and regions.
• Locale-Aware FormattingFormatting numbers, currencies and dates per locale with Intl.
• Localization (l10n)Translating and adapting software for a specific locale.
• Pluralization and ICU MessagesHandling plural rules that differ between languages.
• Product AnalyticsTracking how people use features to inform decisions.
• UX BasicsUsability, feedback, affordances and consistency.

Backend Basics

• Admin and Back-Office ToolsInternal tools for support and operations to view and fix data.
• Application ServerThe process that runs your code behind the web server, like Gunicorn, Puma or Tomcat.
• DTOA plain object for moving data between layers or over the wire.
• Layered ArchitectureControllers, services and data access as separate layers.
• Log Rotation and RetentionKeeping logs from filling the disk.
• ORM vs Raw SQLConvenience and safety vs control and performance.
• Payments IntegrationUsing providers like Stripe safely, with webhooks and idempotency.
• Query BuilderComposing SQL in code without a full ORM.
• Request ContextPer-request data like the current user, request ID and deadline, passed through the code.
• Serverless FunctionsRunning code per request without managing servers.
• Service LayerWhere business logic lives, apart from HTTP and storage.
• Third-Party IntegrationsCalling payment, email and other external APIs reliably.
• Unbounded Result SetsQueries and APIs that return "everything", until everything is a million rows.
• WSGI and ASGIPython's standard interfaces between web servers and applications, synchronous and async.

API Design

• API ContractThe agreed shape and behavior of an API.
• API GatewayA single entry point handling routing, auth and rate limits for many services.
• Backward CompatibilityNew versions that still work with old clients.
• DeprecationMarking something for removal and giving users time to migrate.
• OAuth Scopes and PermissionsLimiting what a token can do, e.g. read-only access.
• Opaque Resource IdentifiersNot leaking database IDs or internal structure in URLs.

Relational Databases & SQL

• Common Table Expression (WITH)Named subqueries that make complex SQL readable.
• Correlated SubqueryA subquery that runs once per row of the outer query.
• Cross JoinEvery row of one table paired with every row of another.
• Database CursorFetching a large result set in batches instead of all at once.
• Dynamic SQLBuilding SQL strings at runtime, and doing it without injection.
• Enums in the DatabaseStoring fixed sets of values safely.
• ER DiagramA diagram of entities and their relationships.
• Full-Text Search in SQLSearching words in text columns with built-in indexes.
• JSON ColumnsStoring semi-structured data inside a relational database.
• Natural vs Surrogate KeyUsing real-world data as the key vs a generated ID.
• Prepared StatementA query parsed once and executed many times with different values.
• Recursive CTEQuerying hierarchies and graphs, like org charts or category trees.
• Relational ModelThe theory behind SQL: relations, tuples, attributes and keys.
• Self JoinJoining a table to itself, e.g. employees and their managers.
• SequenceA database object that generates increasing numbers, used for auto-increment IDs.
• Soft DeleteMarking rows as deleted instead of removing them.
• Stored ProcedureLogic that runs inside the database.
• SubqueryA query nested inside another query.
• Timestamp With vs Without Time ZoneStoring moments in time correctly in the database.
• TriggerCode the database runs automatically on insert, update or delete.
• UpsertInsert, or update if the row exists, in one statement.
• UUID vs Auto-Increment IDsSequential integers vs globally unique IDs, and their trade-offs.
• ViewA saved query that acts like a table.
• Window FunctionsCalculations across related rows, like running totals and rankings.

Indexing & Query Performance

• Eager vs Lazy LoadingLoading related data upfront vs on first access.
• Slow Query LogA record of queries that take too long.
• Unique IndexAn index that also enforces uniqueness.

Transactions & Concurrency Control

• Atomic UpdateLetting the database do the change in one statement, like SET stock = stock - 1.
• AtomicityAll or nothing.
• Lost UpdateTwo writers overwriting each other's changes.
• Read-Modify-Write RaceReading a value, changing it in code and writing it back while someone else does the same.
• SavepointA point inside a transaction you can roll back to.
• Transaction BoundariesDeciding where a transaction should start and end.
• Unique Constraints as a Concurrency GuardLetting the database reject duplicates instead of checking first in code.

NoSQL & Other Data Stores

• Embedded DatabaseA database that runs inside your app, like SQLite.
• Leaderboards with Sorted SetsRanking scores in real time with Redis sorted sets.
• PipeliningSending many commands without waiting for each reply.
• Redis Data StructuresStrings, hashes, lists, sets, sorted sets and streams, and what each is for.
• Search EngineElasticsearch, OpenSearch and others for full-text search.
• Vector DatabaseStoring embeddings for similarity search.

Schema Migrations

• BackfillFilling in data for existing rows after a change.
• Data MigrationMoving or transforming existing data.
• Rolling Back a MigrationUndoing a migration, and why some can't be undone.

Database Operations

• Bulk Loading (COPY)Loading large amounts of data much faster than row-by-row inserts.
• Database Authentication and TLSHow clients prove who they are to the database, and encrypting that connection.
• Database Version UpgradesMoving to a new major version with little downtime.
• Logical vs Physical BackupsSQL dumps vs copies of the data files.
• Roles and Privileges (GRANT, REVOKE)Controlling who can read and change which data.

Caching

• Cache Key DesignChoosing keys so different data never collides.
• CDN CachingCaching content on edge servers near users.
• Eviction PolicyLRU, LFU or FIFO: which item to drop when the cache is full.
• In-Process vs Distributed CacheA cache in your app's memory vs a shared one like Redis.
• Request-Scoped CachingCaching within a single request to avoid repeated lookups.

Queues & Async Processing

• Acknowledgement (ack and nack)A consumer confirming a message was processed, or asking for it to be redelivered.
• Delayed JobsJobs scheduled to run at a later time.
• Job QueueA queue of background tasks with workers, like Sidekiq, Celery or BullMQ.
• Message BrokerMiddleware like RabbitMQ that routes messages.
• Message Envelope and HeadersMetadata travelling with a message: IDs, timestamps, correlation and type.
• Producer and ConsumerThe two sides of a queue.
• Queue Depth and Consumer LagHow far behind consumers are; a key health signal.
• Queue vs TopicPoint-to-point (each message to one consumer) vs pub/sub (each message to every subscriber).
• SubscriptionA consumer's registration to receive messages from a topic.
• Visibility TimeoutHow long a received message stays hidden before it's delivered again.
• WorkerA process that pulls jobs from a queue and runs them.

Email & Notifications

• Email DeliverabilityBounces, spam complaints, sender reputation and staying out of spam folders.
• Notification PreferencesLetting users choose which messages they get, on which channel.
• Push NotificationsSending alerts to phones and browsers through APNs, FCM or Web Push.
• SMS DeliverySending text messages through providers, and the cost and fraud pitfalls.
• SMTPThe protocol for sending email between servers.
• SPF, DKIM and DMARCDNS records that prove your email is really from you, so it doesn't land in spam.

Files & Media

• Data ExportLetting users download their data, often as a background job.
• Image ProcessingResizing, cropping and converting images on upload.
• PDF GenerationProducing PDFs like invoices and reports.
• Presigned URLA temporary URL letting clients upload or download directly from storage.
• Streaming Large FilesProcessing files in chunks instead of loading them into memory.

Product Building Blocks

• Account DeletionDeleting or anonymizing a user across every table and system.
• Approval WorkflowsMulti-step approvals modeled as explicit states and transitions.
• Coupons and DiscountsPromotions without letting them stack or be abused.
• Entitlements and Plan LimitsDeciding which features and quotas each plan unlocks.
• InvitationsInviting people into an organization or team with expiring, single-use links.
• Invoices and ReceiptsGenerating immutable, numbered billing documents.
• Organizations, Teams and MembershipsModeling accounts that many users share, with roles per membership.
• Record History and VersioningKeeping previous versions of rows with history tables or temporal tables.
• Subscription BillingPlans, trials, renewals, failed payments and dunning.
• User-Facing Activity LogShowing users who changed what and when.

Architecture Styles

• N-Tier ArchitectureSeparating presentation, logic and data into tiers.
• Non-Functional RequirementsRequirements about how well a system works rather than what it does.
• Serverless ArchitectureBuilding from managed functions and services without running servers.
• Software ArchitectureThe high-level structure of a system and the decisions that are expensive to change.

Domain-Driven Design

• EntityA domain object defined by its identity.
• Ubiquitous LanguageOne shared vocabulary between developers and domain experts.
• Value ObjectA domain object defined only by its values, and immutable.

System Design Fundamentals

• Clarifying RequirementsAsking what the system must do, and at what scale, before designing it.
• Database Connection PoolReusing database connections, with tools like PgBouncer at scale.
• Designing a URL ShortenerA classic beginner system design exercise.
• Forward ProxyA proxy acting on behalf of clients.
• Reverse ProxyA server in front of your app that handles TLS, routing and caching.
• ScalabilityHandling more load by adding resources.
• Sticky SessionsRouting a user to the same server every time.
• System DesignDesigning the components, data flow and trade-offs of a whole system.
• System Design InterviewThe interview format, and how it differs from real design work.

Distributed Systems

• BASEBasically Available, Soft state, Eventual consistency: the counterpart to ACID.

Reliability & Resilience

• AvailabilityThe share of time a system is usable, often measured in "nines".
• Handling Dependency FailuresDeciding what happens when something you call is down.
• Liveness vs Readiness"Am I running?" vs "Can I take traffic?"
• Nines (99.9%, 99.99%)How much downtime each level of availability allows.
• RedundancyExtra components so a single failure isn't fatal.
• ReliabilityA system doing what it should, even when things fail.
• Restore TestingActually restoring backups regularly to prove they work.
• Single Point of FailureOne component whose failure takes everything down.

Performance & Scalability

• AutoscalingAdding and removing capacity automatically as load changes.
• BatchingGrouping work to reduce per-item overhead.
• BenchmarkingMeasuring performance under controlled conditions.
• BottleneckThe component that limits overall throughput.
• Cold StartThe delay when a serverless function or container starts fresh.
• Moving Work Off the Request PathDoing slow work in the background to keep responses fast.
• Payload SizeSending fewer bytes over the wire.
• PerformanceHow fast and efficiently a system does its work.

Events & Integration

• ETL / ELTExtracting, transforming and loading data between systems.
• EventA record that something happened.
• Unix PhilosophySmall tools that do one thing well and compose through pipes.

Cloud Design Patterns

• Chatty I/OMany small network or database calls where one bigger one would do.
• Competing ConsumersSeveral workers pulling from one queue to share the load.
• External Configuration StoreKeeping configuration in a central service instead of in deploy packages.
• Over-FetchingRetrieving far more data than an operation needs.

Authentication & Authorization

• Access TokenA short-lived token sent with each API request to prove the caller is authenticated.
• Account EnumerationLeaking whether an email is registered through login, signup or reset responses.
• Argon2The current recommended password hashing algorithm; memory-hard to resist GPU cracking.
• Identity Provider (IdP)The service that authenticates users for other apps, like Okta, Auth0 or Google.
• JWT ClaimsThe fields inside a JWT payload, such as sub, exp, iat, iss and aud, and which to check.
• JWT Signing AlgorithmsHS256 (shared secret) vs RS256/ES256 (key pair), and when each fits.
• Login Rate LimitingSlowing or blocking repeated login attempts to stop password guessing.
• Multi-Factor Authentication (MFA)Requiring two or more kinds of proof: something you know, have, or are.
• Password Reset FlowDesigning reset links that are single-use, short-lived and don't leak account existence.
• PKCEAn OAuth extension that stops stolen authorization codes from being exchanged by attackers.
• SameSite CookiesA cookie attribute controlling whether cookies are sent on cross-site requests.
• Token ExpiryChoosing how long tokens live, and handling what happens when they run out.
• TOTPTime-based one-time passwords, the 6-digit codes from authenticator apps.

Web Application Security

• Bot Protection and CAPTCHATelling humans apart from automated abuse.
• Broken Access ControlThe #1 OWASP risk: users acting outside their permissions.
• ClickjackingTricking users into clicking hidden elements inside an iframe.
• Command InjectionRunning shell commands through unsanitized input.
• Content Security PolicyA header restricting which scripts and resources a page may load.
• DDoSOverwhelming a service with traffic from many sources.
• File Upload SecurityValidating the type, size and content of uploaded files.
• Mass AssignmentClients setting fields they shouldn't, like isAdmin.
• Open RedirectA redirect parameter abused to send users to malicious sites.
• Path TraversalReaching files outside an allowed directory with ../.
• Prototype PollutionInjecting properties into JavaScript's Object prototype.
• Security HeadersHTTP headers that harden browsers against attacks.
• Security MisconfigurationDefault passwords, verbose errors and exposed admin panels.
• Stored, Reflected and DOM XSSThe three kinds of XSS and where each comes from.
• Trust BoundaryWhere data crosses from untrusted to trusted; validate there.
• Web Application FirewallFiltering malicious HTTP traffic before it reaches your app.

Cryptography Basics

• Cryptographic Hash (SHA-256)A hash where finding collisions is infeasible.
• CryptographyThe math of keeping data secret and verifying it.
• Digital SignatureProving who created data and that it hasn't been changed.
• Encryption at RestEncrypting stored data on disk.
• HMACA keyed hash proving a message came from someone holding the secret.
• Public-Key CryptographyA public key encrypts or verifies; a private key decrypts or signs.
• Secure Random NumbersCryptographically secure randomness for tokens and keys.
• Symmetric EncryptionOne shared key both encrypts and decrypts, as with AES.

Secure Development

• Attack SurfaceEvery point where an attacker could try to get in.
• Audit LoggingRecording who did what and when, for accountability.
• CVEA public identifier for a known vulnerability.
• Defense in DepthSeveral layers of security, so one failure isn't fatal.
• Dependency ScanningFinding known vulnerabilities in your dependencies.
• SASTStatic analysis that looks for security bugs in source code.
• TyposquattingMalicious packages named like popular ones.
• Zero-DayA vulnerability exploited before a fix exists.

Privacy & Compliance

• CopyleftLicenses that require derivative work to stay open source.
• Data MinimizationCollecting only the data you actually need.
• GDPRThe EU regulation on personal data: consent, access and deletion rights.
• Open Source LicensesMIT, Apache, GPL, and what each one lets you do.

Linux & Servers

• Bare MetalRunning directly on physical servers.
• Disks, Filesystems and MountsAttaching storage and making it usable.
• Hard Link vs Symbolic LinkTwo names for the same file vs a pointer to a path.
• Load AverageA rough measure of how busy a machine is.
• Reading System Logsjournalctl, /var/log, and finding out what went wrong.
• System Monitoring (top, htop, vmstat, iotop)Seeing CPU, memory and disk activity on a machine.
• systemdThe Linux service manager for starting, stopping and logging services.
• Text Processing (sed, awk, cut, sort)Command-line tools for slicing and transforming text.
• tmux / screenKeeping terminal sessions running after you disconnect.
• Users and GroupsHow Linux controls who can do what.

Containers

• Bind Mounts vs VolumesMounting a host directory vs Docker-managed storage.
• Container NetworkingHow containers talk to each other and the outside world.
• ENTRYPOINT and CMDWhat runs when a container starts.
• Hot Reloading in ContainersSeeing code changes instantly while developing in Docker.
• Image Layers and Build CacheHow images are built from cached layers, and how to order steps.
• Image ScanningChecking container images for known vulnerabilities.
• Image Tags and DigestsNaming image versions, and why :latest is risky.
• Running as Non-RootNot running container processes as root.

Kubernetes & Orchestration

• ConfigMap and SecretConfiguration and sensitive values injected into pods.
• Container OrchestrationAutomating the deployment, scaling and healing of containers.
• CrashLoopBackOffA pod that keeps crashing and restarting.
• DeploymentDeclares how many replicas of a pod should run and how to update them.
• HelmA package manager for Kubernetes.
• IngressRouting external HTTP traffic into the cluster.
• Job and CronJobRunning one-off and scheduled tasks in Kubernetes.
• kubectlThe command-line tool for Kubernetes.
• Liveness and Readiness ProbesHow Kubernetes checks whether a container is healthy.
• NamespaceDividing cluster resources between teams or apps.
• NodeA machine in the cluster that runs pods.
• PodThe smallest deployable unit in Kubernetes: one or more containers.
• ReplicaSetKeeps a set number of identical pods running.
• ServiceA stable network address for a set of pods.

Cloud Computing

• ClusterA group of machines working together as one system.
• Functions as a Service (Lambda)Running code in response to events without servers.
• IAM PolicyA document granting permissions on resources.
• Managed Queues (SQS, Pub/Sub)Message queues run by the cloud provider.
• Public vs Private SubnetSubnets reachable from the internet vs only from inside.
• Regions and Availability ZonesGeographic locations, and isolated data centers within them.
• Security GroupA virtual firewall around cloud resources.
• Service AccountAn identity for software rather than a person.
• VPCA private network in the cloud.

Infrastructure as Code

• Configuration Management (Ansible)Automating the setup of servers.
• Declarative vs Imperative InfrastructureDescribing the end state vs listing the steps.
• Pets vs CattleHand-tended servers vs interchangeable, replaceable ones.
• Terraform / OpenTofuDeclarative infrastructure provisioning across providers.

CI/CD & Deployment

• Artifact RepositoryStorage for built packages and images.
• Blue-Green DeploymentSwitching traffic between two identical environments.
• Build CachingReusing previous build outputs to make CI fast.
• Deploy vs ReleaseShipping code vs exposing it to users.
• Deployment FreezeA period when deploys are paused, like around holidays.
• Preview EnvironmentA temporary deployment for each pull request.
• Roll ForwardFixing a bad deploy with a new deploy instead of reverting.
• Rolling DeploymentReplacing instances a few at a time.
• Secrets in CIHandling credentials safely in pipelines.

Observability

• Alert FatigueSo many alerts that people start ignoring them.
• APMApplication performance monitoring tools.
• Four Golden SignalsLatency, traffic, errors and saturation.
• Log AggregationCollecting logs from every server into one searchable place.
• Logs, Metrics and TracesThe three main kinds of telemetry.
• ObservabilityUnderstanding a system's internal state from its outputs.
• Prometheus and GrafanaA common open-source stack for metrics and dashboards.

Incidents & SRE

• Blameless PostmortemFocusing on systems rather than individuals when things go wrong.
• Emergency Change ProcessShipping urgent fixes safely under pressure.
• EscalationKnowing when and how to pull in more help.
• Incident ResponseHow a team detects, coordinates, fixes and communicates during an incident.
• Incident Severity LevelsSEV1 to SEV4: how bad an incident is.
• Mitigate First, Fix LaterStopping the bleeding before hunting for the root cause.
• PagingAlerts that wake someone up.
• SLAA service level agreement: a promise to customers, with consequences.
• Status PagePublic communication about outages.

Working in Production

• Ad-Hoc Queries on ProductionQuerying live data without hurting it: read replicas, timeouts and LIMIT.
• Feature Flag CleanupRemoving flags once rollout is done so they don't pile up as debt.
• Fixing Data in ProductionCorrecting bad rows safely: a reviewed script, a backup, and a record of what changed.
• Launch ChecklistMonitoring, rollback, docs and support readiness before something goes live.
• Maintenance WindowA scheduled, announced time for risky changes.
• On-Call HandoverPassing open issues and context to the next person on call.
• One-Off ScriptsScripts run once against production, and why they deserve review and tests too.
• Production ConsolesInteractive shells against live data, like a Rails or Django console, and their dangers.
• Reproducing Production Issues LocallyRecreating a production bug with realistic, anonymized data.

Collection & Instrumentation

• Client-Side vs Server-Side TrackingRecording events in the browser or app vs on your servers, and what each misses.
• Consent at CollectionOnly collecting what users agreed to, and recording that they agreed.
• Tracking PlanA shared spec of which events to track, their names and their properties.
• User-Generated ContentPosts, reviews, uploads and messages as a data source.
• Web ScrapingExtracting data from websites, and its legal and reliability limits.

Ingestion

• Messages vs StreamsTransient queued messages vs a durable, replayable log of events.

Serving & Analytics

• Data APIsServing data to applications through an API instead of direct database access.

Data Engineering Basics

• Analytics Event TrackingRecording user actions for later analysis.
• Data PipelineA sequence of steps that moves and transforms data.
• Data WarehouseA database optimized for analytics, like BigQuery or Snowflake.
• OLTP vs OLAPTransaction processing vs analytical queries.

Machine Learning Basics

• Deep LearningNeural networks with many layers.
• Machine LearningSoftware that learns patterns from data instead of following explicit rules.
• ModelThe learned function that turns inputs into predictions.
• Neural NetworkLayers of weighted connections that learn from data.
• Supervised LearningLearning from labeled examples.
• Training vs InferenceBuilding a model vs using it to make predictions.

LLM & AI Engineering

• AI AgentA model that plans and takes actions with tools in a loop.
• EmbeddingsNumeric vectors representing meaning, used for similarity search.
• How LLMs WorkTokens in, next-token prediction out: a mental model of what's happening.
• Multimodal ModelsModels that handle images, audio and text together.
• Prompt EngineeringWriting instructions that get reliable results from a model.
• Prompt InjectionUntrusted text hijacking a model's instructions.
• Retrieval-Augmented Generation (RAG)Giving a model relevant documents so it answers from your data.
• Semantic SearchSearching by meaning instead of keywords.
• Streaming ResponsesShowing model output token by token as it's generated.
• Structured OutputGetting models to return valid JSON matching a schema.
• System PromptInstructions that set a model's behavior for a conversation.
• TemperatureA setting controlling how random a model's output is.
• TokenThe unit of text a model reads and writes, and what you pay for.
• Tool Use / Function CallingLetting a model call your functions and APIs.

Agile & Delivery Process

• Continuous Improvement (Kaizen)Small, ongoing improvements to how the team works.
• Definition of ReadyWhat a ticket needs before work on it starts.
• Iterative DeliveryShipping a thin working slice first, then improving it.
• MVPThe smallest product that tests whether an idea works.
• TriageSorting incoming bugs and requests by urgency and impact.
• VelocityHow much work a team finishes per sprint, and how it gets misused.
• Vertical SliceA feature built through every layer, end to end.
• WIP LimitCapping how many tasks are in progress at once.

Estimation & Planning

• Buffers and UnknownsAccounting for the work you can't see yet.
• Hofstadter's LawIt always takes longer than you expect, even when you account for this.
• MilestoneA significant checkpoint in a project.
• Ninety-Ninety RuleThe last 10% of the work takes the other 90% of the time.
• Scope CreepRequirements growing while a project is underway.
• SpikeA time-boxed investigation to reduce uncertainty.
• T-Shirt SizingRough S/M/L/XL estimates for early planning.

Communication

• Async CommunicationWriting so people can respond on their own time.
• Effective MeetingsAgendas, notes, clear decisions, and fewer meetings.
• Making Work Visible RemotelyOver-communicating when nobody can see you working.
• Saying NoDeclining or pushing back on work constructively.
• Working with DesignersCollaborating on how it should look and behave.
• Working with Product ManagersCollaborating on what to build and why.

Product Thinking

• DogfoodingUsing your own product.
• Functional vs Non-Functional RequirementsWhat it does vs how well it does it.
• Handling Support EscalationsInvestigating issues reported by customers.

Career Growth

• Career ConversationsDiscussing goals and growth with your manager.
• Compensation and NegotiationSalary, equity and bonuses, and negotiating offers.
• Mid-Level EngineerDelivering features independently.
• PromotionShowing next-level scope before you get the title.
• T-Shaped SkillsBroad knowledge with deep expertise in one area.

Functional Programming

• CurryingTurning a multi-argument function into a chain of single-argument ones.
• MonadA pattern for chaining computations that carry context, like Option or Promise.
• Referential TransparencyAn expression can be replaced by its value without changing behavior.

Error Handling

• Graceful DegradationLosing non-critical features instead of failing completely.

Type Systems

• Algebraic Data TypesComposing types from "and" (products) and "or" (sums).
• Covariance and ContravarianceHow subtyping of generic types follows their type parameters.
• Structural vs Nominal TypingCompatible by shape vs compatible by declared name.

Concurrency & Async

• Actor ModelConcurrency through isolated actors that communicate by messages.
• BackpressureA slow consumer signalling a fast producer to slow down.
• ChannelA typed pipe for passing values between concurrent tasks.
• Green Threads / GoroutinesLightweight threads scheduled by the runtime rather than the OS.
• LivelockTasks keep reacting to each other without making progress.
• SemaphoreA counter limiting how many tasks can use a resource at once.
• StarvationA task never gets the resources it needs to run.

Memory & Runtime

• Buffer OverflowWriting past the end of a buffer and corrupting memory; a classic vulnerability.
• Dangling PointerA pointer to memory that has already been freed.
• EndiannessThe byte order of multi-byte numbers in memory.
• JIT CompilationCompiling hot code to machine code while the program runs.
• Manual Memory ManagementAllocating and freeing memory yourself, as in C.
• Object PoolingReusing objects to avoid the cost of allocating new ones.
• Ownership and BorrowingRust's compile-time rules that prevent memory bugs without a GC.
• Reference CountingFreeing an object when nothing refers to it anymore.
• Weak ReferenceA reference that doesn't keep its object alive.

Version Control (Git)

• Git InternalsBlobs, trees, commits and refs: what Git actually stores.
• Monorepo vs PolyrepoOne repository for everything vs one per project.
• Patch FilesSharing changes as diff files instead of branches.
• WorktreeSeveral working directories checked out from one repository.

Pull Requests & Code Review

• Stacked PRsA chain of dependent pull requests, each reviewable on its own.

Debugging

• Core DumpA snapshot of a crashed process's memory for later analysis.
• Debugging in ProductionFinding issues with logs, traces and metrics when you can't attach a debugger.
• Flame GraphA visualization of where a program spends its time.

Testing

• Contract TestingVerifying that services agree on the API contract between them.
• FuzzingFeeding random inputs to find crashes and vulnerabilities.
• Mutation TestingChanging code on purpose to check that the tests notice.
• Property-Based TestingGenerating many inputs to check that properties always hold.
• Soak TestRunning under load for hours to find leaks and slow degradation.
• Stress TestingPushing beyond capacity to find the breaking point.
• Testing in ProductionValidating safely with real traffic using flags, canaries and monitoring.

Clean Code & Principles

• Functional Core, Imperative ShellPure logic in the middle, side effects at the edges.
• Gall's LawComplex systems that work evolved from simple systems that worked.
• Keep Framework Code at the EdgesKeeping business logic free of framework details so it survives framework changes.
• Postel's LawBe conservative in what you send and liberal in what you accept.

Refactoring

• Big Bang RewriteReplacing a whole system at once, and why it usually fails.
• Parallel Change (Expand-Contract)Add the new way, migrate callers, then remove the old way.
• SeamA place where you can change behavior without editing the code there.
• Strangler Fig PatternGradually replacing a legacy system by routing pieces to new code.

Design Patterns

• Abstract FactoryCreating families of related objects without naming concrete classes.
• BridgeSeparating an abstraction from its implementation so both can vary.
• Data MapperA separate layer moving data between objects and the database.
• Domain ModelOrganizing business logic as objects that hold both data and behavior.
• FlyweightSharing common state among many small objects to save memory.
• Identity MapEnsuring each database row is loaded into only one object per session.
• MediatorCentralizing communication between objects.
• MementoCapturing state so it can be restored later, as in undo.
• Patterns of Enterprise Application ArchitectureFowler's catalog: transaction script, domain model, data mapper and more.
• PrototypeCreating objects by cloning an existing one.
• Service LocatorA registry for looking up dependencies, often seen as an anti-pattern.
• Type ObjectDefining "kinds" of things as data instead of subclasses.
• Unit of WorkTracking changes and committing them in one transaction.
• VisitorAdding operations to a structure without changing its classes.

Documentation & Writing

• C4 ModelDiagramming software at four zoom levels: context, containers, components, code.
• DiátaxisOrganizing docs into tutorials, how-to guides, reference and explanation.

Data Structures

• Balanced TreeTrees like AVL or red-black that stay shallow for guaranteed O(log n).
• Bloom FilterA compact structure answering "definitely not" or "probably yes" for set membership.
• HyperLogLogEstimating the number of distinct items with tiny memory.
• K-D TreeA tree for searching points in multi-dimensional space.
• Merkle TreeA tree of hashes that verifies large data efficiently.
• Persistent Data StructureAn immutable structure that shares unchanged parts between versions.
• Ring BufferA fixed-size buffer that wraps around.
• Segment TreeA tree for fast range queries over arrays.
• Skip ListA layered linked list with O(log n) search.
• Union-FindTracking which elements belong to the same group.

Algorithms

• Bellman-Ford AlgorithmShortest paths that also handles negative edge weights.
• Classic Hard ProblemsKnapsack, traveling salesman and others, and how to recognize them in disguise.
• Consistent HashingHashing that moves only a few keys when servers are added or removed.
• Diff AlgorithmsComputing the minimal set of changes between two sequences.
• Dijkstra's AlgorithmFinding shortest paths in a graph with non-negative weights.
• Huffman CodingCompressing data by giving frequent symbols shorter codes.
• Minimum Spanning TreeConnecting all nodes with the least total edge weight (Prim's, Kruskal's).
• P vs NP / NP-CompleteProblems with no known efficient solution, and why some tasks stay hard.
• String SearchingAlgorithms like KMP and Rabin-Karp for finding substrings.

Math for Programmers

• Amdahl's LawThe speedup from parallelism is limited by the part that stays sequential.
• Linear Algebra BasicsVectors and matrices, the foundation of graphics and ML.
• Little's LawItems in a system = arrival rate × time each spends in it.

Computer Architecture

• Cache LocalityAccessing memory that's close together is much faster.
• InterruptA signal that makes the CPU pause and handle an event.
• RegistersThe tiny, fastest storage inside the CPU.

Operating Systems

• cgroupsLinux control groups that limit resources; one basis of containers.
• Context SwitchThe CPU switching between threads or processes, and what it costs.
• CPU SchedulerHow the OS decides which thread runs next.
• epoll / kqueueOS mechanisms for watching many sockets efficiently.
• fork and execHow Unix creates new processes by copying, then replacing, the current one.
• InodeThe file system record that holds a file's metadata.
• Inter-Process CommunicationPipes, sockets and shared memory for processes to talk to each other.
• Linux NamespacesIsolating what a process can see; the other basis of containers.
• Memory-Mapped FilesMapping a file directly into a process's memory.
• Paging and SwapMoving memory pages to disk when RAM is full.
• Scheduling AlgorithmsRound robin, priority and fair scheduling for sharing the CPU.
• User Space vs Kernel SpaceThe privilege boundary between programs and the OS.

Compilers & Languages

• Cross-CompilationBuilding for a platform different from the one you're on.
• Domain-Specific LanguageA small language built for one problem, like SQL or regex.
• Lexer / TokenizerSplitting source text into tokens.
• LinkingCombining compiled code and libraries into an executable.
• MacroCode that expands into other code at compile time.
• MetaprogrammingCode that writes or modifies code.
• Static vs Dynamic LinkingBundling libraries into the binary vs loading them at runtime.
• WebAssemblyA portable binary format that runs near-native code in browsers and beyond.

Networking Fundamentals

• AnycastOne IP address served from many locations, sending users to the nearest.
• ARPFinding the hardware address behind an IP on a local network.
• Head-of-Line BlockingOne slow item holding up everything queued behind it.
• MTUThe largest packet size a network link can carry.
• Network PartitionPart of a network becoming unreachable from the rest.
• Packet Capture (tcpdump, Wireshark)Recording and inspecting raw network traffic.
• QUICA UDP-based transport behind HTTP/3, with faster handshakes.
• RoutingHow packets find their way across networks.

HTTP

• Chunked Transfer EncodingStreaming a response in pieces without knowing its total size.
• Conditional RequestIf-None-Match and If-Match for caching and concurrency control.
• HTTP/3HTTP running over QUIC.
• Range RequestsFetching part of a resource, for resumable downloads and video.

TLS & Certificates

• Certificate ChainLeaf, intermediate and root certificates linking to a trusted root.
• SNITelling the server which hostname you want during the TLS handshake.
• TLS HandshakeHow client and server agree on keys before sending data.

API Styles & Formats

• AvroA binary serialization format whose schemas are designed to evolve.
• DataLoader / N+1 in GraphQLBatching resolver lookups so nested queries don't explode.
• MessagePackA compact binary alternative to JSON.
• REST vs GraphQL vs gRPCChoosing an API style for the clients and teams you have.
• Richardson Maturity ModelLevels of REST maturity, from one endpoint to hypermedia.
• Schema EvolutionChanging data formats so old and new readers and writers keep working.
• SOAPAn older XML-based protocol for web services.

Real-Time Communication

• CRDTData structures that merge concurrent edits without conflicts, used in collaborative editors.
• PresenceShowing who is online or viewing something right now.
• WebRTCPeer-to-peer audio, video and data in the browser.

Rendering Strategies

• CSR vs SSR vs SSGChoosing a rendering strategy for SEO, speed and complexity.
• Edge RenderingRendering close to users on CDN edge servers.

Web Performance

• Real User Monitoring (RUM)Measuring performance from real users' browsers.

Backend Basics

• Choosing a Backend LanguageWeighing ecosystem, performance and team skills.
• Context PropagationCarrying request IDs, deadlines and trace context across threads and services.
• Let It CrashRestarting a failed component cleanly instead of handling every error inside it.
• Multi-TenancyServing many customers from one system while keeping their data apart.
• Steady StateDesigning systems to clean up after themselves: purging data, rotating logs.
• Worker and Process ModelsPre-fork workers, threads or an event loop: how a server handles many requests at once.

API Design

• API-First DesignDesigning the API contract before implementing it.
• Backend for Frontend (BFF)A backend tailored to one frontend's needs.
• Bulk OperationsEndpoints that act on many items in one request.
• Designing WebhooksSignatures, retries, ordering and idempotency for outgoing webhooks.
• HATEOASResponses that include links to the possible next actions.
• Long-Running OperationsReturning 202 Accepted and a status URL for slow work.
• Public vs Internal APIsWhy public APIs need much more care about stability.
• Rate Limiting AlgorithmsToken bucket, leaky bucket, fixed window and sliding window.
• Sparse FieldsetsLetting clients choose which fields they receive.

Relational Databases & SQL

• DenormalizationDeliberately duplicating data for read performance.
• LATERAL JoinA join where the right side can reference columns from the left.
• Materialized ViewA view whose results are stored and refreshed.
• Pivot / UnpivotTurning rows into columns and back.
• Query PlanThe database's chosen strategy of scans, joins and sorts.
• Relational AlgebraThe operations (select, project, join) that SQL queries compile to.
• Sequential Scan vs Index ScanReading the whole table vs jumping in through an index.

Indexing & Query Performance

• Covering IndexAn index containing every column a query needs.
• Hash IndexAn index for equality lookups only.
• Index SelectivityHow well an index narrows down rows.
• Partial IndexAn index over only the rows matching a condition.
• Specialized Indexes (GIN, GiST, BRIN)Index types for JSON, full-text search, geometry and huge tables.
• Table StatisticsData distributions the planner uses to choose query plans.
• VACUUM and BloatCleaning up dead rows in PostgreSQL.

Transactions & Concurrency Control

• Database DeadlockTransactions waiting on each other's locks.
• Dirty ReadReading another transaction's uncommitted data.
• Distributed TransactionA transaction that spans several databases or services.
• MVCCMulti-version concurrency control, where readers don't block writers.
• Non-Repeatable ReadReading the same row twice and getting different values.
• Phantom ReadRows appearing or vanishing between reads in one transaction.
• Row Locks vs Table LocksHow much a lock blocks.
• Two-Phase CommitA coordinator making all participants either commit or abort.
• Write SkewTwo transactions reading the same data and making conflicting writes.
• Write-Ahead LogLogging changes before applying them, for durability and replication.

Database Internals

• B-Tree vs LSM TreeRead-optimized pages vs write-optimized logs, and when each wins.
• Buffer Pool / Page CacheKeeping hot disk pages in memory.
• CheckpointFlushing in-memory changes to disk so recovery doesn't replay the whole log.
• fsync and DurabilityWhat "written to disk" actually means, and when data can still be lost.
• LSM TreeA write-optimized structure that buffers writes in memory and merges sorted files.
• Snapshot IsolationEach transaction reads from a consistent snapshot of the database.
• SSTables and CompactionSorted immutable files and the background process that merges them.
• Storage EngineThe part of a database that reads and writes data on disk.
• System CatalogThe tables where a database describes its own schema.

NoSQL & Other Data Stores

• Atomic Scripts (Lua in Redis)Running several operations atomically on the server.
• Designing for Access PatternsModeling NoSQL data around the queries you'll run.
• Faceted SearchFiltering search results by categories with counts.
• Fuzzy SearchMatching despite typos and spelling variations.
• Geospatial DataStoring and querying locations: nearby search, distances, geohashes.
• Graph DatabaseDatabases like Neo4j built around relationships.
• Inverted IndexA map from words to the documents that contain them.
• NewSQL / Distributed SQLSQL databases that scale horizontally, like CockroachDB or Spanner.
• Polyglot PersistenceUsing different databases for different needs in one system.
• Redis Persistence (RDB, AOF)Snapshots vs an append-only log for surviving restarts.
• Redis Sentinel and ClusterFailover and sharding for Redis.
• Relevance Scoring (BM25)Ranking search results by how well they match.
• Single-Table DesignStoring many entity types in one DynamoDB table.
• Time-Series DatabaseDatabases optimized for timestamped measurements.
• Tokenizers and AnalyzersHow search engines split and normalize text before indexing.
• Wide-Column StoreDatabases like Cassandra built for massive write volume.

Schema Migrations

• Migration LocksSchema changes that lock tables and take production down.
• Online Schema Change ToolsTools like gh-ost for altering huge tables safely.

Database Operations

• Database ExtensionsAdding capabilities to a database, like PostGIS or pgvector.
• Database High AvailabilityAutomatic failover for databases, with tools like Patroni.
• Key-Range vs Hash PartitioningSplitting data by ranges of keys vs by hashed keys.
• Last Write WinsResolving conflicting writes by timestamp, and the data it silently loses.
• Leaderless ReplicationAny node accepts writes, with quorums to reconcile, as in Cassandra.
• Point-in-Time RecoveryRestoring a database to any moment using a base backup plus the log.
• Query Statistics (pg_stat_statements)Finding which queries use the most time in aggregate.
• Row-Level SecurityThe database itself filtering rows per user or tenant.
• Streaming vs Logical ReplicationCopying the raw log vs copying row changes, and what each lets you do.
• Synchronous vs Asynchronous ReplicationWaiting for replicas to confirm vs not, trading safety for latency.
• Table PartitioningSplitting one huge table into smaller physical pieces, e.g. by month.
• Using the Database as a QueueJob queues in SQL with SKIP LOCKED, and when that's enough.

Caching

• Cache ConsistencyKeeping cached data in line with the source of truth.
• Cache WarmingFilling a cache before traffic arrives.
• Negative CachingCaching "not found" results too.
• Read-Through CacheThe cache itself loads missing data from the database.
• Thundering HerdMany clients waking up and hitting a resource at the same moment.
• Write-Behind CacheWriting to the cache now and to the database later.
• Write-Through CacheWriting to the cache and the database together.

Queues & Async Processing

• Apache KafkaA distributed, durable log for high-volume event streaming.
• Consumer GroupConsumers sharing the work from a topic.
• Consumer OffsetA consumer's position in a log, which it commits as it goes.
• Delivery GuaranteesAt-most-once, at-least-once and exactly-once delivery.
• Event StreamingProcessing a continuous flow of events.
• Exactly-Once SemanticsThe hard, often misunderstood guarantee of processing each message once.
• Exchanges and Routing KeysHow brokers like RabbitMQ route a message to the right queues.
• Fan-OutSending one message to many consumers.
• Inbox PatternRecording received messages so duplicates can be ignored.
• JitterRandomizing retry delays so clients don't all retry in sync.
• Message OrderingWhen and how messages arrive in order.
• Message TTL and ExpiryDropping or dead-lettering messages that are too old to matter.
• Poison MessageA message that crashes every consumer that tries to process it.
• Push vs Pull ConsumersThe broker delivering messages vs consumers fetching them at their own pace.
• Stream ProcessingComputing over events as they arrive, as with Flink.
• Topics and PartitionsHow Kafka-style logs split and order messages.
• Workflow EngineDurable orchestration of long multi-step processes, like Temporal.

Email & Notifications

• IMAP and POP3Protocols for reading email from a mailbox.

Files & Media

• Video Streaming (HLS)Serving video as adaptive chunks.

Product Building Blocks

• Inventory and ReservationsTemporarily holding stock or seats so two buyers can't get the last one.
• Ledger and Double-Entry BookkeepingRecording money movements as balanced, append-only entries.
• Multi-Currency HandlingStoring, converting and displaying money in several currencies.
• ProrationCharging fairly when a customer changes plans mid-cycle.
• Recurring EventsRepeating schedules, RRULE, and their time zone edge cases.
• Sales Tax and VATCharging the right tax for each customer's location.
• Usage MeteringCounting billable usage accurately, without double-counting.

Architecture Styles

• Clean ArchitectureConcentric layers whose dependencies point inward to the domain.
• Distributed MonolithMicroservices so coupled they must deploy together: the worst of both worlds.
• Hexagonal ArchitecturePorts and adapters that isolate core logic from infrastructure.
• Onion ArchitectureA layered style with the domain model at the center.
• Peer-to-PeerNodes that act as both client and server.
• Pipes and FiltersProcessing data through a chain of independent steps.
• Plugin ArchitectureA core extended by independently developed plugins.
• Quality Attributes (the "-ilities")Scalability, availability, maintainability and other non-functional goals.
• Service-Oriented ArchitectureAn older style of large shared services, often joined by an enterprise bus.

Domain-Driven Design

• AggregateA cluster of objects treated as one unit for changes.
• Aggregate RootThe single entry point for modifying an aggregate.
• Anemic Domain ModelDomain objects with data but no behavior.
• Anti-Corruption LayerA translation layer protecting your model from another system's.
• Domain EventA record that something meaningful happened in the domain.
• Domain ServiceDomain logic that doesn't belong to any one entity.
• Event StormingA workshop for discovering a domain through its events.

System Design Fundamentals

• Coordination ServiceSystems like ZooKeeper and etcd for configuration, locks and leader election.
• Data LocalityKeeping data close to where it's processed.
• Database FederationSplitting databases by function, e.g. users and orders in separate databases.
• Designing a Chat SystemReal-time messaging, presence and message storage.
• Designing a News FeedFan-out on write vs on read, a classic design problem.
• Designing a Notification SystemFan-out across email, SMS and push, with preferences and retries.
• Designing a Rate LimiterCounting requests across many servers under high load.
• Designing AutocompleteTries, ranking and caching for type-ahead search.
• Distributed ID GenerationGenerating unique IDs across machines, e.g. UUIDv7 or Snowflake IDs.
• Event SourcingStoring every change as an event and deriving state from them.
• Hot PartitionOne shard getting far more traffic than the others.
• Hot, Warm and Cold StorageTiering data by how often it's accessed.
• L4 vs L7 Load BalancingBalancing by connection vs by HTTP content.
• Leader-Follower ReplicationOne node takes writes; followers copy them and serve reads.
• Load Balancing AlgorithmsRound robin, least connections and consistent hashing.
• Multi-Leader ReplicationSeveral nodes accept writes and sync with each other.
• PartitioningDividing data into parts, within one machine or across many.
• Push vs Pull CDNUploading content to the CDN vs letting it fetch on demand.
• Read-Heavy vs Write-HeavyHow the dominant traffic shape drives the design.
• Read-Your-Writes ConsistencyUsers always seeing their own updates.
• RebalancingMoving data around when shards are added or removed.
• Refresh-Ahead CacheRefreshing cache entries before they expire.
• Shard KeyThe field that decides which shard data lives on.

Distributed Systems

• Change Data CaptureStreaming database changes out as events.
• Choreography vs OrchestrationServices reacting to events vs a central coordinator directing them.
• Clock SkewMachines' clocks disagreeing, which breaks time-based ordering.
• ConsensusGetting nodes to agree on a value despite failures.
• Data Consistency Across ServicesKeeping data correct when each service owns its own database.
• Database per ServiceEach microservice owning its data exclusively.
• Distributed LockMutual exclusion across machines, and its pitfalls.
• Gossip ProtocolNodes spreading information by talking to random peers.
• HeartbeatPeriodic "I'm alive" signals used to detect failed nodes.
• Idempotency in Distributed SystemsMaking retries safe when you can't know whether the first attempt worked.
• Leader ElectionChoosing one node to coordinate the others.
• LeaseA lock or role that expires automatically unless renewed.
• PACELCExtends CAP: even without partitions, you trade latency against consistency.
• QuorumRequiring a majority of nodes to agree on reads or writes.
• RaftAn understandable consensus algorithm, used in etcd.
• Request CoalescingCollapsing identical concurrent requests into one.
• Service DiscoveryHow services find each other's addresses.
• Service MeshInfrastructure handling service-to-service traffic, retries and mTLS.
• SidecarA helper process deployed alongside each service.
• Split BrainTwo nodes both believing they're the leader.
• Strong ConsistencyEvery read sees the latest write.
• Two Generals' ProblemWhy agreement over an unreliable link can't be guaranteed.

Reliability & Resilience

• Active-Active vs Active-PassiveAll nodes serving traffic vs standbys waiting.
• BulkheadIsolating resources so one failure doesn't sink everything.
• Compensating TransactionUndoing a completed step with a new action, since you can't roll it back.
• Deadline PropagationPassing the remaining time budget down a chain of calls.
• Degraded ModesServing reduced functionality when dependencies fail.
• Disaster RecoveryRestoring service after a catastrophic failure.
• FailoverSwitching to a standby when the primary fails.
• Fault ToleranceContinuing to work when components fail.
• Load SheddingRejecting some requests on purpose to protect the rest.
• Retry StormRetries multiplying the load on an already failing system.
• RPO and RTOHow much data you can afford to lose, and how long you can be down.
• Self-Healing SystemsAutomatically restarting and replacing failed parts.
• Thread Pool ExhaustionAll workers stuck waiting on something slow, so nothing else gets served.

Performance & Scalability

• Continuous ProfilingProfiling live services to find hot paths.
• PrecomputationComputing results ahead of time.

Events & Integration

• Batch vs Stream ProcessingProcessing data in periodic chunks vs continuously.
• Distributed Batch ProcessingEngines like Spark that split big jobs across many machines.
• Event BusA channel through which events reach their subscribers.
• Event Schema VersioningEvolving event formats without breaking consumers.
• Event vs Command"This happened" vs "please do this".
• MapReduceProcessing huge datasets by mapping in parallel and then reducing the results.
• Schema RegistryA central store of event schemas and their compatibility rules.
• Stream WindowingGrouping events by time windows: tumbling, sliding and session windows.

Cloud Design Patterns

• AmbassadorA helper proxy that handles networking concerns for a service.
• Busy DatabasePushing too much processing into the database.
• Claim CheckPutting a large payload in storage and sending only a reference through the queue.
• GatekeeperA dedicated host that validates requests before they reach trusted services.
• Gateway AggregationOne gateway call that fans out to many services and combines the results.
• Gateway OffloadingMoving TLS, auth and other shared concerns into the gateway.
• Index TableA separate table that indexes data by a field the main store can't query efficiently.
• Noisy NeighborOne tenant or workload hogging shared resources and slowing others down.
• Priority Queue PatternProcessing urgent messages before others.
• Queue-Based Load LevelingA queue absorbing traffic spikes so a service sees steady load.
• Scheduler Agent SupervisorCoordinating a multi-step job and recovering steps that fail.
• Sequential ConvoyProcessing related messages in order while unrelated ones run in parallel.

Authentication & Authorization

• ABACAttribute-Based Access Control: decisions based on attributes of user, resource and context.
• Client Credentials FlowThe OAuth 2.0 flow for machine-to-machine calls with no user involved.
• Credential StuffingAutomated logins using username/password pairs leaked from other sites.
• DAC, MAC and PBACOwner-controlled, centrally mandated and policy-based access control.
• JWKSJSON Web Key Set: a published endpoint of public keys used to verify signed tokens.
• mTLSMutual TLS: both client and server present certificates, common for service-to-service auth.
• Passkeys (WebAuthn)Phishing-resistant login with device-bound key pairs instead of passwords.
• ReBACRelationship-Based Access Control, as in Google Zanzibar: access follows relationships like owner or member.
• SAMLAn older XML-based standard for enterprise SSO, still common in B2B.
• Session FixationAn attack where the attacker sets a victim's session ID before login; fixed by rotating the ID on login.
• Signing Key RotationReplacing token signing keys regularly without invalidating every live token.
• Single Sign-On (SSO)Logging in once with an identity provider and accessing many apps.
• Token RevocationStrategies for invalidating tokens before they expire: denylists, versioning, short lifetimes.

Web Application Security

• Business Logic VulnerabilitiesAbusing legitimate features in unintended ways.
• Insecure DeserializationDeserializing untrusted data in a way that executes code.
• ReDoSRegular expressions that take exponential time on crafted input.
• SSRFTricking a server into making requests to internal systems.
• XXEXML parsers fetching external entities and leaking files.

Cryptography Basics

• End-to-End EncryptionOnly the communicating users can read the data, not the server.
• Envelope EncryptionEncrypting data with a data key, then encrypting that key with a master key.
• Key Management (KMS)Generating, storing, rotating and controlling access to keys.
• Nonce / IVA value used once so encrypting the same data gives different output.
• Timing AttackLeaking secrets through how long comparisons take.

Secure Development

• Bug BountyPaying outside researchers to report vulnerabilities.
• Container SecurityMinimal images, non-root users and image scanning.
• CVSSA score rating how severe a vulnerability is.
• DASTTesting a running app for vulnerabilities from the outside.
• Penetration TestingAuthorized simulated attacks to find vulnerabilities.
• Responsible DisclosureReporting vulnerabilities privately before going public.
• SBOMA software bill of materials listing every component.
• Secret RotationRegularly replacing credentials.
• Security ReviewReviewing a design or change specifically for security risks.
• Shift-Left SecurityFinding security issues early in development.
• Software Supply Chain SecurityProtecting against compromised dependencies and build pipelines.
• STRIDEA way to categorize threats: spoofing, tampering, repudiation, disclosure, denial of service, elevation.

Privacy & Compliance

• Anonymization vs PseudonymizationIrreversibly vs reversibly removing identity from data.
• CCPACalifornia's consumer privacy law.
• Data RetentionHow long to keep data, and when to delete it.
• HIPAAUS rules for protecting health information.
• PCI DSSRules for handling payment card data.
• Privacy by DesignBuilding privacy in from the start.
• Right to ErasureDeleting a user's data on request, across every system.

Linux & Servers

• HypervisorSoftware that runs virtual machines.
• iptables / nftablesLinux's built-in firewall.
• Linux Boot ProcessFirmware, bootloader, kernel, init: how a machine starts.
• LVMFlexible logical volumes on top of physical disks.
• Process Priority (nice)Telling the scheduler which processes matter more.
• SELinux and AppArmorMandatory access control that restricts what processes can do.
• Server HardeningReducing a server's attack surface.
• straceWatching the system calls a process makes.

Containers

• Minimal Base ImagesAlpine, distroless and scratch images for a smaller attack surface.
• OCIThe open standards for container images and runtimes.
• Union FilesystemStacking read-only image layers with a writable layer on top.

Kubernetes & Orchestration

• Control PlaneThe components that manage cluster state.
• DaemonSetRunning one pod on every node.
• Horizontal Pod AutoscalerAdding pods automatically based on load.
• Managed Kubernetes (EKS, GKE, AKS)Kubernetes with a cloud-run control plane.
• Network PoliciesFirewall rules between pods.
• Node Affinity and Topology SpreadControlling which nodes pods run on and how they spread out.
• Persistent VolumeStorage that survives pod restarts.
• Pod Disruption BudgetLimiting how many pods can be down during maintenance.
• Pod Priority and PreemptionEvicting less important pods to make room for important ones.
• Requests and LimitsHow much CPU and memory a pod reserves and is allowed to use.
• Resource QuotasCapping what a namespace can use.
• StatefulSetRunning stateful apps with stable identity and storage.
• Taints and TolerationsKeeping pods off nodes unless they explicitly allow it.
• Vertical Pod AutoscalerAdjusting a pod's CPU and memory requests automatically.

Cloud Computing

• Cloud Cost Management (FinOps)Understanding and controlling cloud spending.
• Edge ComputingRunning code near users at CDN locations.
• Egress CostsPaying for data leaving the cloud.
• External Secrets in KubernetesSyncing secrets from a vault into the cluster safely.
• Managed vs Self-HostedPaying for convenience vs running it yourself.
• Shared Responsibility ModelWhich security duties belong to the provider and which are yours.
• Storage Lifecycle PoliciesAutomatically moving or deleting old objects.
• Vendor Lock-InDepending on one provider's proprietary services.

Infrastructure as Code

• Configuration DriftReal infrastructure diverging from its definition.
• GitOpsGit as the source of truth, with agents syncing the cluster to it.
• Immutable InfrastructureReplacing servers instead of changing them.
• Pulumi and CDKInfrastructure defined in general-purpose programming languages.
• Terraform StateThe record of what infrastructure exists, and why it must be protected.

CI/CD & Deployment

• Dark LaunchRunning new code in production without users seeing it.
• Deploying Schema and Code TogetherOrdering migrations and code changes so neither breaks the other.
• Deployment FrequencyHow often a team ships; a key DevOps metric.
• Progressive DeliveryGradual rollouts with automatic checks at each step.
• Release TrainShipping on a fixed schedule with whatever is ready.

Observability

• Actionable AlertsAlerting only on symptoms that need a human to act.
• CardinalityThe number of unique label combinations, and why high cardinality gets expensive.
• Counter, Gauge, HistogramThe basic metric types.
• OpenTelemetryThe vendor-neutral standard for collecting telemetry.
• RED MethodRate, errors and duration for request-driven services.
• SamplingRecording only a fraction of traces or logs to control cost.
• SpanOne timed operation within a trace.
• USE MethodUtilization, saturation and errors for resources.

Incidents & SRE

• Customer Communication in IncidentsTelling users what's happening, honestly and promptly.
• Incident CommanderThe person coordinating an incident response.
• MTTR / MTTDMean time to recover, and to detect.
• Runbook AutomationTurning manual runbook steps into scripts.
• Site Reliability EngineeringApplying software engineering to operations.
• SLIA service level indicator: a measured aspect of service quality.
• ToilManual, repetitive operational work that should be automated.

Working in Production

• Break-Glass AccessEmergency elevated access that is logged, time-limited and reviewed afterwards.

Collection & Instrumentation

• Telemetry PipelineThe path from emitted logs, metrics and events to where they're stored and queried.

Serving & Analytics

• Embedded AnalyticsShowing charts and reports inside your product to customers.

Data Engineering Basics

• Columnar StorageStoring data by column for fast analytics.
• Data LakeCheap storage for raw data in any format.
• Data QualityMaking sure data is accurate, complete and fresh.
• dbtTransforming warehouse data with versioned SQL.
• ParquetA columnar file format for analytics.
• Pipeline Orchestration (Airflow)Scheduling and managing data pipelines.

Machine Learning Basics

• Classification vs RegressionPredicting categories vs predicting numbers.
• FeatureAn input variable a model uses.
• Model ServingDeploying a model behind an API.
• OverfittingA model memorizing its training data instead of generalizing.
• Recommendation SystemSuggesting items based on behavior and similarity.
• Train / Test SplitHolding out data to evaluate a model honestly.
• Unsupervised LearningFinding structure in unlabeled data.

LLM & AI Engineering

• Choosing a ModelTrading off quality, speed and cost across model sizes and providers.
• ChunkingSplitting documents into pieces for embedding and retrieval.
• EvalsSystematically measuring the quality of LLM output.
• Fine-TuningFurther training a model on your own examples.
• GuardrailsChecks on model inputs and outputs for safety and correctness.
• LLM Cost and LatencyManaging tokens, model choice and caching.
• LLM-as-JudgeUsing one model to grade another model's output.
• Prompt CachingReusing processed prompt prefixes to save cost and time.
• RerankingRe-ordering retrieved results with a stronger model.

Agile & Delivery Process

• Cycle Time and Lead TimeHow long work takes from start, or from request, until it's done.
• Lean Software DevelopmentEliminating waste and optimizing the flow of work.
• Shape UpBasecamp's six-week cycles with shaped, fixed-time bets.

Estimation & Planning

• Cone of UncertaintyEstimates get more accurate as work progresses.
• Critical PathThe chain of tasks that determines the earliest finish date.
• Cross-Team DependenciesWork blocked on other teams, and how to manage it.
• OKRsObjectives and key results for setting goals.
• Project KickoffAligning everyone on goals, scope and roles at the start.
• RICE and MoSCoWFrameworks for prioritizing work.
• RoadmapA plan of what to build over the coming months.

Communication

• Disagree and CommitVoicing disagreement, then fully backing the decision.
• PresentingCommunicating ideas to a group.
• Psychological SafetyFeeling safe to take risks and admit mistakes on a team.
• Resolving ConflictWorking through disagreements productively.
• Stakeholder ManagementKeeping the people affected by your work informed and aligned.

Product Thinking

• Build vs BuyDeciding whether to build something or use an existing product.
• Business MetricsRevenue, retention, conversion: what the business measures.
• Experimentation CultureTesting ideas with data before committing to them.
• Feature AdoptionWhether users actually use what you shipped.
• User ResearchLearning what users actually need.

Career Growth

• Generalist vs SpecialistThe trade-offs between breadth and depth.
• Glue WorkEssential but invisible work that keeps teams running.
• IC vs Management TrackTwo parallel career paths, and how to choose between them.
• Senior EngineerOwning systems and raising the team around you.
• Tech LeadLeading a team's technical direction while still writing code.
• Writing and Speaking PubliclyBlogs, talks and sharing what you learn.

Technical Leadership

• Boring Technology / Innovation TokensSpending novelty sparingly and choosing proven tools by default.
• DelegationHanding off work in a way that grows others.
• Developer ExperienceHow easy and pleasant it is for engineers to do their work.
• HiringInterviewing and selecting engineers.
• Interviewing CandidatesRunning fair interviews that produce real signal.
• Managing UpKeeping your manager informed and aligned.
• Onboarding New EngineersHelping new teammates become productive.
• Technical LeadershipGuiding technical direction through influence and example.