Engineering glossary

Terms from the SWE Interview Guide, explained in plain English.

amortized: average cost per op over a long run. Hash insert is O(1) amortized even though rehash is O(n) occasionally.
in-place: algorithm uses O(1) extra space (mutates input).
stable sort: equal elements keep original relative order. Matters for multi-key sorts.
monotonic: strictly increasing or strictly decreasing. Often a stack/deque invariant.
memoization: top-down DP: cache results of recursive calls.
tabulation: bottom-up DP: fill an array iteratively.
invariant: property maintained at every loop step.
DAG: directed acyclic graph. Topo sort works only on DAGs.
greedy: locally best choice. Works only when an exchange argument proves global optimality.
heap-pop k times: O(k log n). Useful for "top k" reasoning.
indegree: # of incoming edges. Topo sort starts from indegree-0 nodes.
Floyd's algorithm: fast/slow pointers for cycle detection in O(1) space.
bitmask DP: state = subset of items as bits in an int. Only feasible for n ≤ 20.
α(n): inverse Ackermann. Effectively constant for any realistic n. Used to describe DSU complexity.
idempotent: doing an operation twice has the same effect as once. What makes retries safe (e.g. an idempotency key).
CI/CD: continuous integration / delivery: automated build + test + ship on every push, so breakage is caught before merge.
flaky test: a test that passes and fails without code changes. Poison for CI — trains the team to ignore red builds.
canary deploy: release to a tiny slice of traffic first, watch, then ramp. Blue-green flips all traffic at once; rolling replaces in batches.
feature flag: a runtime toggle to ship code "dark" and enable/roll back instantly without a redeploy.
image / container: image = the frozen blueprint (code + deps); container = a running instance of it. One image, many identical containers.
orchestration: running many containers across machines (scheduling, self-healing, scaling). Kubernetes is the common tool; a Service fronts churning pods.
IAM / least privilege: identity & access management: grant the minimum permissions needed. Misconfigured IAM is the #1 cloud-breach cause.
VPC: virtual private cloud: your private network slice. Public subnets face the internet; private ones (apps, DBs) do not.
CAP theorem: during a network partition you must choose consistency or availability — you cannot keep both.
eventual consistency: reads may be briefly stale, then converge. Fine for a like count; use strong consistency for a bank balance.
backoff + jitter: retry after exponentially growing, randomized delays. Jitter prevents synchronized retry storms (thundering herd).
circuit breaker: after too many failures, "trip" and fail fast for a cooldown instead of hammering a dead dependency — stops cascades.
observability: being able to ask new questions of a running system. Built on the three pillars: logs, metrics, traces.
SLI / SLO / error budget: SLI = a measured number; SLO = its target (e.g. 99.9%); error budget = the allowed failure (the leftover 0.1%).
p99 / tail latency: the 99th-percentile response time — what your slowest 1% of users feel. Watch the tail, not the average.
coupling / cohesion: low coupling = modules barely depend on each other; high cohesion = related things live together. The core of maintainable design.
technical debt: the future cost of a quick-now solution. Fine when taken on deliberately and repaid; deadly when unintentional and ignored.
Big-O: how runtime or memory grows as input size n grows — the language for comparing algorithms.
binary search: search a sorted array by halving the remaining range each step — O(log n).
boolean: a true/false value used in conditions and logic.
bottleneck: the slowest or most repeated step in an approach — optimize this first.
brute force: try every possibility; correct but often too slow; name it before improving.
collision: two different keys landing in the same hash slot — handled by chaining or open addressing.
conditional: an if/elif/else branch that runs different code based on a test.
cyclic sort: place each value at index value−1 when values are in range 1..n — O(n) in-place reorder.
debugger: a tool that runs code step-by-step and inspects variables to find bugs.
dictionary: a key→value map for O(1) average lookup by key (Python dict, JS Map/object).
DSA: data structures and algorithms — the core of most coding interviews.
expression: code that evaluates to a value, e.g. 2 + 3 or len(arr).
function: a named, reusable chunk of code with parameters and an optional return value.
hash map: structure mapping keys to values with O(1) average lookup — the interview workhorse.
hash table: same idea as hash map; implemented with a bucket array plus a hash function.
index: position of an item in a list or string — usually zero-based in Python/JS.
integer: whole number type (int) — no fractional part.
key-value pair: one entry in a map: a lookup key and the value stored under it.
linked list: nodes chained by next pointers — O(1) insert at head, O(n) random access.
list: ordered collection of items, accessible by index.
loop: repeated execution — for (fixed count/range) or while (until condition).
operator: symbol that combines values: + − * /, comparisons == <, logic and/or.
parameter: named input a function receives when called.
prefix sum: running totals prefix[i] = sum of arr[0..i] — answers range-sum queries in O(1).
queue: FIFO structure — enqueue at back, dequeue from front.
return value: what a function sends back to its caller with return.
set: unordered collection of unique items — O(1) average membership test.
sliding window: maintain a contiguous subarray/substring and update in O(1) per step as bounds move.
stack: LIFO structure — push/pop at one end; used for nesting and monotonic patterns.
string: ordered sequence of characters (text).
time complexity: how runtime scales with input size — stated with Big-O.
space complexity: how extra memory scales with input size — also Big-O.
traceback: error report showing the call stack when a program crashes — read bottom-up to the cause.
two pointers: two indices moving through a structure — often from both ends on sorted data.
type: category of value (int, float, str, bool, list, …) — determines valid operations.
variable: a named box holding a value you can read and update.
ACID: atomicity, consistency, isolation, durability — guarantees for database transactions.
API: application programming interface — a defined way for programs to call each other (often HTTP + JSON).
backtracking: try a choice, recurse, undo if it fails — explores a search tree.
BFS: breadth-first search — explore layer by layer with a queue; shortest path in unweighted graphs.
binary tree: tree where each node has at most two children — base for many recursive algorithms.
cache: fast store of frequently used data to avoid repeating expensive work.
CDN: content delivery network — edge servers that cache static assets close to users.
consistent hashing: ring-based sharding so adding/removing a node moves only a small key slice.
DFS: depth-first search — go deep with recursion/stack before backtracking.
Dijkstra: shortest-path algorithm for non-negative edge weights using a min-heap.
dynamic programming: break problem into overlapping subproblems; cache results — optimal when optimal substructure holds.
horizontal scaling: add more machines to handle load (scale out).
isolation level: how much one transaction sees of others' uncommitted work — tradeoff vs concurrency.
JWT: JSON Web Token — signed payload the client sends to prove identity without server session storage.
knapsack: DP family: pick items with weight/value constraints to maximize total value.
load balancer: distributes incoming requests across healthy backend servers.
microservices: many small services owning bounded domains vs one monolithic app.
monotonic stack: stack keeping increasing or decreasing order — "next greater element" pattern.
OAuth: delegated authorization — let users sign in via a provider without sharing their password.
pub-sub: publishers emit events; subscribers receive by topic — decouples producers and consumers.
rate limiter: caps requests per user/IP/window — protects backends from overload and abuse.
replication: copies of data on multiple nodes — for read scale and failover.
REST: HTTP API style using nouns (resources) and verbs (GET/POST/PUT/DELETE) with stateless requests.
segment tree: tree over an array supporting range queries/updates in O(log n).
sharding: split data across partitions/servers by a key (user_id, hash, range).
SQL: structured query language for relational databases — SELECT/JOIN/GROUP BY.
TLS: transport layer security — encrypts traffic in transit (HTTPS).
topological sort: linear order of DAG nodes where every edge goes forward — course prerequisites.
transaction: group of DB operations that commit or roll back as one unit.
tree: connected acyclic graph with a root — hierarchical data (DOM, file systems).
trie: prefix tree over characters — fast prefix lookup for strings/autocomplete.
union-find: disjoint-set structure for connected components — near O(1) union/find with path compression.
vertical scaling: make one machine bigger (more CPU/RAM) — scale up.
WebSocket: persistent bidirectional TCP channel — real-time chat and live updates.
a11y: accessibility — designing so people with disabilities can perceive and operate the UI.
agent: LLM-driven system that plans, calls tools, and loops until a goal is met.
behavioral interview: questions about past behavior ("tell me about a time…") — STAR answers.
context window: max tokens an LLM can read/write in one call — drives chunking and RAG design.
DOM: document object model — browser tree of page elements your JS/CSS manipulate.
embedding: numeric vector representing meaning — similar text → nearby vectors for search.
eval: systematic measurement of model/app quality on a fixed dataset — gates shipping.
fine-tuning: training a base model further on your labeled data for a specialized task.
hydration: React attaching client JS to server-rendered HTML — mismatch causes errors.
LLM: large language model — predicts next tokens; powers chat, code, and agents.
LLM-as-judge: using an LLM to score outputs against rubrics — cheap scale, needs calibration.
on-call: rotation where engineers respond to production alerts outside business hours.
postmortem: blameless write-up after an incident — timeline, root cause, follow-ups.
prompt: instructions and context sent to an LLM — quality of prompt strongly affects output.
prompt injection: user text that hijacks model instructions — treat untrusted input as hostile.
pull request: proposed code change for team review before merge — core of team git flow.
RAG: retrieval-augmented generation — fetch relevant docs, then ask the LLM with that context.
React: UI library building interfaces from components and declarative state.
semantic HTML: real elements (<button>, <nav>, <main>) instead of generic <div>s — accessibility and SEO.
STAR: Situation, Task, Action, Result — frame for behavioral interview stories.
streaming: send model output token-by-token as generated — better UX for long responses.
system design: designing scalable services — requirements, APIs, data, bottlenecks, tradeoffs.
token: chunk a model reads/writes — roughly word pieces; billing and limits are token-based.
vector database: store optimized for similarity search on embeddings — RAG retrieval layer.
WCAG: Web Content Accessibility Guidelines — contrast, keyboard, labels; AA is the common bar.
context engineering: deciding what goes into the model's context window and in what order — budgeting tokens across system prompt, retrieved docs, history, and examples.
FDE: forward-deployed engineer — customer-facing SWE who builds on-site with the client; graded on product judgment and speed, not just code.
MCP: Model Context Protocol — a standard way to expose tools and data sources to any LLM; the USB of agent tooling.
RLHF: reinforcement learning from human feedback — training a model on human preference comparisons; what turned raw next-token predictors into helpful assistants.
barge-in: user interrupting a voice agent mid-speech — handling it (stop audio, cancel generation, listen) is core realtime-voice engineering.
guardrail: deterministic check around an LLM (input filter, output validator, approval gate) — safety lives in code, not in the prompt.
tool calling: LLM emitting a structured function call your code executes — the primitive under every agent.
CBW sentence: how a senior states a design decision: Choice → Benefit → Cost → Why-acceptable-here. Volunteer the cost before the interviewer finds it.
LRU eviction: least-recently-used: when a cache is full, drop the key untouched longest. O(1) via a hash map + doubly-linked list.
cache stampede: a hot key expires and thousands of requests miss at once, stampeding the DB. Fix: a single-flight lock or serve-stale-while-refresh.
geohash: encodes (lat, lng) into a short string where nearby points share a prefix — turning 2-D proximity search into a 1-D prefix lookup.
quadtree: recursively splits a region into four quadrants, subdividing only where points are dense. Density-adaptive alternative to a fixed geohash.
inference: running a trained model to get one output (a prediction, embedding, or generated answer). The per-request cost; training is the offline job that made the model.
latency budget: the total time allowed for a request, divided across its hops. If the model alone eats 400ms of a 500ms budget, everything else must fit in 100ms.
idempotency key: a unique client-generated id for an intent (e.g. one payment attempt) sent with every retry, so the server applies it once no matter how many times it arrives.
append-only ledger: store money as immutable entries and derive the balance from their sum, never an overwritten number. Gives a full audit trail.
saga: coordinate a multi-step flow across systems you cannot wrap in one transaction; on a later failure, run compensating actions (e.g. a refund) instead of a rollback.
reconciliation: a periodic job comparing your records against an external source of truth (e.g. the payment processor) to flag and repair drift.