Core jargon for software architecture, delivery, and engineering culture.
A way of describing how an algorithm's run time or memory use grows as its input size grows, ignoring constant factors.
The single slowest component in a system that caps overall speed, no matter how fast every other part runs.
Storing the result of expensive work so a later request can reuse it instead of recomputing or refetching from scratch.
Breaking a bundle into multiple smaller chunks that load on demand rather than shipping everything upfront, so the initial page load only pays for what it immediately needs.
A code path that runs rarely, so its performance has little effect on the system overall.
Making progress on multiple tasks over the same time period by switching between them — not necessarily running them at the exact same instant.
Delaying execution of a function until a specified quiet period has passed since the last time it was called — collapsing a burst of rapid calls into one.
Loading related data upfront, before it's needed, trading extra initial work for fewer round-trips later.
A code path that executes very frequently relative to the rest of the system, making its performance disproportionately important to optimize.
The delay between starting an operation and getting its result back, typically measured in milliseconds for a single request.
Deferring the loading of a resource until the exact moment it's actually needed.
Caching a function's return value keyed by its input, so calling it again with the same input skips recomputation entirely.
A synchronization primitive that ensures only one thread can access a shared resource at a time — others wait until the lock is released.
A data-fetching pattern where you make one query to get a list of N items, then run one additional query per item to fetch related data — totaling N+1 round-trips instead of one.
Actually running multiple tasks at the exact same instant, across multiple CPU cores or machines simultaneously.
A bug where the program's outcome depends on the unpredictable ordering of concurrent operations, producing different results depending on timing.
Limiting a function to fire at most once per defined time interval, regardless of how many times it's invoked.
The volume of work a system can complete in a given time period, such as requests handled per second.