Concepts
Start from an idea, then go deeper to the products. Learn what a queue or a table format does once, and every product that implements it makes sense. 133 concepts in 5 areas.
Looking for a product? Search all 405 technologies →Build
How code is written, and how a system is split into parts.
Programming topic page →
How code is organized, and how it runs on many cores at once.- Programming languages15 technologiesWhat actually separates one language from another in practice: how the code runs, when types are checked, who frees memory, and which styles of program and concurrency it makes easy.
- Static dispatchThe compiler decides which function each call runs, so the program jumps straight to it, or skips the call by inlining it.
- Dynamic dispatchThe function a call runs is chosen at run time from the object it’s called on, usually through a table of function pointers.
- Runtime virtual machines3 technologiesA program that runs other programs: compilers emit portable bytecode, and the runtime loads it, compiles the busy parts to machine code, collects garbage and schedules work on whatever machine it lands on.
- Foreign function interfaces1 technologyHow code in one language calls functions compiled from another: both sides meet at the platform’s C calling convention, and glue code converts values and settles who frees what.
- Data structuresWays to lay data out in memory so the operations a program runs most are fast; you choose one by the operations you need and what each one costs.
- Purely functional data structures6 technologiesCollections that are never changed in place: every update returns a new version that shares most of its memory with the old one, and every old version stays valid.
- Object-oriented programming3 technologiesBundle data with the code allowed to change it into objects, and let callers ask an object to do something without knowing how it does it.
- Functional programming5 technologiesBuild programs from functions that take values and return new values, without changing anything else along the way.
- MonadsA wrapper type plus one rule for chaining steps, so the plumbing (missing values, errors, waiting, state) is written once instead of after every step.
- DRY: Don’t Repeat YourselfEvery fact a system knows should live in one place, so changing a rule is one edit; it is about duplicated knowledge, not about code that happens to look alike.
- Service layerPut business logic in stateless services, like `OrderService.placeOrder`, that load plain data objects, apply the rules, and save the result.
- Data transfer objects1 technologyA plain object that only carries data across a boundary (a network call, an API, a message), shaped for that trip rather than for the business logic behind it.
- Object-relational mapping9 technologiesA library that turns rows in relational tables into objects in your program and back, so ordinary code can read and save data without hand-writing every SQL statement.
- Errors and exceptionsHow a function reports that it couldn’t do its job, either as a value the caller has to check or as an exception that jumps up the call stack to whoever catches it, and why expected failures and bugs deserve different treatment.
- Optional valuesA type that says a value may be missing, so the compiler makes you handle “nothing” before you use it, instead of a null that crashes at run time.
- Base Class Library patternsThe few recurring shapes the .NET Base Class Library uses everywhere (`IDisposable` and `using`, `TryParse`, `Task`-returning `Async` methods, `EventHandler<T>` events, `yield` iterators), so every .NET type behaves the way callers already expect.
- MultithreadingSeveral threads of one program run at once, on separate cores or taking turns, all sharing the same memory.
- Amdahl’s lawThe part of a job that can’t run in parallel caps how much faster more workers can make it.
- Synchronous and asynchronous executionWhether a call makes its caller wait for the result (synchronous) or hands control back at once and delivers the result later (asynchronous), and the ways languages let code wait without holding a thread.
- Event loopOne thread waits on thousands of sockets at once and runs a short callback whenever one of them is ready.
- Binary parsing and encoding5 technologiesReading and writing bytes laid out in a fixed format, such as packet headers, file headers and firmware messages, without trusting what those bytes claim about themselves.
- UI libraries2 technologiesReusable interface parts: styled components you drop in and theme, or headless ones that handle state, keyboard and accessibility while you write the markup and styles.
System design topic page →
How one system is split into deployable parts.- MonolithsThe whole application is built, tested and deployed as one unit, usually with one database.
- MicroservicesSplit one application into small services that each own their data and can be deployed on their own.
- Serverless architecture1 technologyBuild an application from managed services and short-lived functions, so none of the servers are yours to run.
- Domain-driven design1 technologyShape the software around the business it serves: one shared language with the domain experts, explicit boundaries where words change meaning, and building blocks such as aggregates that guard the rules.
- CQRS1 technologyCommand Query Responsibility Segregation: one model handles changes and enforces the rules, separate read models answer queries, and the read side catches up from the changes.
- Static read models3 technologiesRender the views readers need ahead of time, as JSON, HTML or Parquet files in object storage behind a CDN, so a read is a file fetch with no database on the path. Also called ahead-of-time view generation or precomputed read models.
Developer tools topic page →
The editors, agents and toolchains code is written and checked with.- Editors and terminals3 technologiesThe editor where code is written and the terminal where it runs: two old tools that now reach language servers, debuggers and coding agents through open protocols.
- AI coding agents9 technologiesA language model in a loop with tools: it reads files, runs commands and edits code, sees each result, and decides the next step until the task is done.
- Package managers3 technologiesTools that choose versions for a project’s dependencies, record the exact choice in a lockfile and install that same set on every machine.
- Linters, formatters and type checkers4 technologiesTools that read source code without running it: linters flag likely bugs, formatters reprint the layout, and type checkers check that values have the types the code claims.
- Automated testing4 technologiesCode that checks other code: a runner finds the tests, runs them and reports what failed, so every change is checked in seconds instead of by hand.
- Bundlers and dev servers3 technologiesFollow every `import` from an entry file to build a module graph, serve it quickly while you code, and pack it into a few small files for production.
- Documentation sites1 technologyDocs written as Markdown files in a repository, built into a searchable website on every merge, with API reference generated from the API’s own description and plain-text copies for AI agents.
Infrastructure
Where code runs, and how its parts reach each other.
Compute topic page →
Where your code actually runs.- Cloud service modelsIaaS, CaaS, PaaS, FaaS and SaaS: how much of the stack you hand to a provider, from renting bare virtual machines to just using someone else’s application.
- Platform as a service (PaaS)10 technologiesYou hand the platform your code or a container image, and it builds it, runs it as a set of long-lived processes, routes requests to them, restarts them when they fail and scales them, so you never manage servers or an operating system.
- Serverless functions (FaaS)12 technologiesUpload a function; the cloud runs it only when something happens.
- Software as a service (SaaS)Software you use over the network while the provider runs all of it; for the people building it, one system that serves many customers (tenants) without letting them see or slow each other.
- Virtual machines12 technologiesA whole computer, carved out of a bigger physical one.
- Hypervisors10 technologiesThe layer that splits one physical computer into several virtual ones, each with its own CPUs, memory, devices and kernel.
- MicroVMs5 technologiesA stripped-down virtual machine that boots as fast as a container, with its own kernel.
- Containers8 technologiesYour app and everything it needs, packed into one portable image.
- Container orchestration7 technologiesSoftware that keeps your containers running, wherever there’s room.
- Autoscaling1 technologyAdd machines when load rises, remove them when it falls.
- Actor model4 technologiesMany small stateful objects, each with a mailbox, that handle one message at a time and are spread across a cluster by their ID.
Networking topic page →
How requests find their way in.- Network protocols7 technologiesThe agreed rules that move bytes between machines, stacked in layers: IP finds the host, a transport such as TCP or UDP finds the program, TLS keeps it private, and HTTP or FTP says what the bytes mean.
- Load balancers4 technologiesSpreads incoming traffic across healthy servers.
- Load-balancing algorithmsThe rule a load balancer uses to pick which healthy server gets the next request or connection.
- CDNs3 technologiesCopies of your content cached close to your users.
- API gateways2 technologiesThe front door for your APIs: auth, limits and routing in one place.
- DNS3 technologiesThe internet’s phone book: turns names into addresses.
- Virtual private clouds1 technologyYour own private, isolated network inside the cloud.
- Service discovery & mesh3 technologiesHow services find each other’s healthy instances, and a layer of proxies that secures and steers the calls between them.
- Remote procedure calls4 technologiesCall a function on another machine as if it were local: a shared interface, generated stubs and a compact encoding.
- Web APIs2 technologiesA service exposed over plain HTTP, as resources with URLs (REST) or as one typed graph (GraphQL), so any browser, app or partner can call it.
- API frameworks2 technologiesLibraries that turn ordinary functions into HTTP or GraphQL endpoints: they route each request, parse and check its input, serialize the result and describe the API for docs and generated clients.
Messaging topic page →
How services hand work and events to each other.- Message queues11 technologiesA to-do list between services: each job is done once, by one worker.
- Event streams10 technologiesAn append-only log of events that many readers replay at their own pace.
- Stream processing16 technologiesQueries that never finish: they read events as they arrive and keep results, counts and joins up to date.
- Pub/sub10 technologiesPublish one message; every subscriber gets its own copy.
- Event buses2 technologiesA router that sends each event to whoever has a rule for it.
- Workflow orchestration6 technologiesA durable state machine that drives multi-step processes to completion.
- IoT device messaging6 technologiesA broker that keeps a connection open to every device in a fleet, knows who each one is, and copes with devices that keep dropping offline.
Storage topic page →
Where files and disks live.- Object storage17 technologiesPractically unlimited storage for files of any size, addressed by key.
- Block storage2 technologiesA virtual hard drive you attach to one machine.
- File storage5 technologiesA shared network drive that many servers mount at once.
- Backup & restore3 technologiesCopies of your data kept apart from the original, so you can get it back after a deletion, corruption, ransomware or a lost region.
Data
Storing, shaping and querying data.
Databases topic page →
Structured data, shaped for how you query it.- Relational databases21 technologiesTables, SQL and transactions: the dependable default.
- Key-value stores10 technologiesPut a value under a key and get it back by that key, fast, at almost any scale.
- Document databases3 technologiesRecords stored as JSON documents that the database can query, index and update field by field.
- Wide-column stores3 technologiesHuge tables split into partitions by key, with rows kept sorted inside each one, built for heavy writes.
- Graph databases3 technologiesStore things and the links between them as first-class data, and answer questions by walking the links instead of joining tables.
- Caching7 technologiesKeep hot data in memory so you don’t ask the slow system twice.
- In-process cachesA small cache inside your service’s own memory: no network hop, but every copy of the service has its own.
- Time-series databases13 technologiesA database shaped for measurements stamped with time.
- Search indexes5 technologiesFind rows or files by what’s inside them: an index from words or character fragments to the places they appear.
- Vector databases3 technologiesStore embeddings, lists of numbers that capture what text, images or users mean, and find the ones closest to a query.
- Coordination services4 technologiesA small, strongly consistent store, usually three or five servers, that a distributed system uses to agree on who leads, who holds a lock and what the configuration is.
- Database indexes1 technologyA structure kept in step with a table that lets the database find matching rows without reading the whole table, paid for on every write.
- LSM trees1 technologyA storage structure that buffers writes in a sorted in-memory table, flushes them to immutable sorted files and merges those files in the background, trading extra reads and rewrites later for fast, sequential writes now.
- Unbounded queriesA query with no time range, no partition key and no LIMIT, whose cost grows with every row ever stored.
Data modeling topic page →
How to lay out tables for data that changes shape or time.- CRUDCreate, read, update, delete: the four basic things you do to stored records, mapped to SQL’s `INSERT`, `SELECT`, `UPDATE` and `DELETE` and to HTTP’s `POST`, `GET`, `PUT` or `PATCH`, and `DELETE`.
- Wide tablesOne row per entity and moment, with a typed column for every attribute or metric, so related values sit side by side.
- Hybrid (medium) tablesThe middle ground: a metric-name column plus a few typed value columns, or fixed columns plus a JSON or map column for the rest.
- Emergent schema (JSON columns)Keep the fields you know as columns and the rest in a JSON column, then promote keys to real columns once the data shows which ones matter.
- Narrow tablesOne row per entity, time and metric, with the metric’s name in one column and its value in another: the long or tall format.
- Entity-attribute-value (EAV)Store each fact as its own row of entity, attribute and value, so adding an attribute never changes the schema.
- Bitemporal modeling1 technologyRecord two timelines for every fact, when it was true in the world and when the database knew it, so you can correct the past without losing what you once believed.
- Persistence: state, events and replay3 technologiesThree ways to make data and work survive a restart: store the current state, store every change as an event, or store a program’s progress and replay it.
Analytics topic page →
Turning piles of files into answers.- File formats17 technologiesHow rows and columns are laid out inside a data file, which decides how much a query has to read.
- Table formats12 technologiesA metadata layer that turns a folder of data files into a real table, with transactions, schema changes and time travel.
- Lakehouse catalogs7 technologiesThe service every engine asks “where is this table right now?”: it maps table names to their current metadata, makes commits atomic, and decides who may read which files.
- Query engines31 technologiesCompute that runs SQL over data it doesn’t own, and scales separately from the storage.
- Data warehouses9 technologiesA columnar database for big analytical questions over all your data.
- Real-time analytics databases11 technologiesColumnar databases that make streaming events queryable within seconds and answer many small analytical queries at once, fast enough to sit behind an app.
- Data lakes3 technologiesRaw files of any kind in cheap storage, given a structure only when someone reads them.
- Lakehouses21 technologiesWarehouse-style tables on open files in object storage, shared by every engine.
- ETL & ELT pipelines13 technologiesCopy data from app databases, SaaS APIs, files and streams into a warehouse or lake, then reshape it into tables people can query.
- Semantic layers2 technologiesOne shared, code-defined model of metrics, dimensions and joins that BI tools, apps and AI agents query by name, which the layer compiles to SQL against the warehouse and often caches.
- Data notebooks2 technologiesA document of code cells, their outputs and notes, backed by a live process that keeps variables in memory, so you can explore data a step at a time and keep the results next to the code that made them.
Ship & run
Getting changes to production, then keeping it healthy and safe.
Delivery topic page →
From a commit to running in production.- Version control1 technologyRecord every change to the code as a commit, so anyone can see who changed what, when and why, and get any earlier version back.
- Branching strategiesA team’s rules for how changes flow into the shared code and out to releases: which branches exist, how long they live, and how they get merged.
- Commit conventionsShared rules for what goes into one commit and how its message is written, so the history explains itself and tools can read it.
- Build toolsTurn source code into runnable artifacts, rebuilding only what changed since last time.
- CI/CD pipelines4 technologiesAn automated path from a commit to production.
- Rolling deploymentsReplace the instances of a service a few at a time, so it keeps serving while the new version takes over.
- Blue-green deploymentsRun two full copies of production, release to the idle one, then switch all traffic over at once; switching back is the rollback.
- Canary releasesSend a small share of real traffic to the new version, compare it with the old one, and widen the share only while it looks healthy.
- Infrastructure as code6 technologiesDescribe your infrastructure in files and let a tool build it.
- Local cloud emulators3 technologiesA process on your laptop or CI runner that answers a cloud provider’s API, so tests and dev loops run with no account, no bill and no network.
Observability topic page →
Knowing what production is doing, and acting when it breaks.- Observability14 technologiesLogs, metrics and traces that tell you what your system is doing.
- Logs11 technologiesTimestamped records of what a program did, written as it runs and shipped somewhere you can search them.
- Structured loggingLogs written as named fields (logfmt or JSON) instead of free text, so a machine can filter, group and join them.
- Metrics7 technologiesNumbers measured over time, such as requests per second, error rate or p95 latency: cheap enough to keep for every service and to alert on.
- Distributed tracing7 technologiesFollow one request through every service it touches, as a tree of timed spans that share one trace ID.
- Correlation IDsOne ID per request, created at the edge and carried through every service, message and log line, so you can find everything that request did.
- Error tracking3 technologiesCatch every exception with its stack trace and context, and fold thousands of copies into one issue you can fix.
- Synthetic monitoring3 technologiesRobots that use your product from outside on a schedule, so you learn it’s broken before a customer tells you.
- Alerting4 technologiesRules that watch your metrics and logs and wake a human only when users are, or are about to be, hurt.
- On-call1 technologyA rotation of engineers who carry the pager, so a real person answers when production breaks at 3 a.m.
- Incident management1 technologyWhen something big breaks: declare it, give one person command, keep everyone informed, stop the damage, then learn from it without blame.
Security topic page →
Who may sign in, and what they may touch.- Authentication3 technologiesProving who a user is, before anyone decides what they may do.
- Identity & access (IAM)3 technologiesWho can do what, to which resource.
- Secrets management4 technologiesA locked vault for passwords, keys and tokens, handed out at runtime.
- Remote access3 technologiesHow people, scripts and AI agents reach private servers and databases without a public IP or a shared VPN.
- Common Vulnerabilities and Exposures (CVE)A public ID such as CVE-2021-44228 that names one known vulnerability, so every scanner, advisory and patch note can point at the same flaw.
- Threat detection (SIEM)2 technologiesCollecting security logs from many systems in one place and running detection rules over them, so that suspicious activity becomes an alert an analyst can act on.
Teams
Working together: how teams are shaped and how work flows.
Organization topic page →
How people split, plan and support the work.- Team structuresWho works with whom, who decides what, and who looks after each person: from flat companies with no managers to layered hierarchies.
- Issue trackingOne shared list of every bug and piece of work, each with a status, an owner and a priority, so nothing lives only in someone’s head or inbox.
- SprintsWork in fixed time-boxes of a few weeks: pick a goal, build it, show it, look back, and start the next one.
- Customer supportHow customers’ questions and problems reach the people who can solve them, and how those problems flow back into the product.