System Architecture

Cover processors, memory, storage, buses, instruction execution, and input/output. Trace a request through the hardware layers that carry out the work.

Explain processes, threads, virtual memory, files, permissions, scheduling, and system calls. Use command-line tools to inspect how an application consumes operating-system resources.

Cover packets, addresses, routing, ports, DNS, TCP, UDP, HTTP, TLS, and network boundaries. Follow a browser request from a client through the internet to a server.

Compare memory, local disks, network storage, object storage, and archival storage by durability, latency, throughput, and cost. Design a simple storage hierarchy for an application.

Trace the shift from mainframes and time-sharing through client-server systems, the web, virtualization, cloud computing, and distributed platforms. Connect each era to the constraints and architectural practices it produced.

Turn stakeholder needs into functional requirements, constraints, assumptions, risks, and measurable acceptance criteria. Produce a requirements brief for a small system.

Work with performance, availability, scalability, security, maintainability, usability, interoperability, and cost as measurable architectural goals. Resolve conflicts through scenarios and explicit trade-offs.

Represent systems with context, container, component, sequence, deployment, and data-flow diagrams. Apply C4 and selected UML notation without letting diagrams become unnecessary paperwork.

Use cohesion, coupling, information hiding, separation of concerns, dependency direction, and stable interfaces to manage complexity. Refactor a tightly connected design into clear modules.

Apply layered, client-server, pipe-and-filter, hexagonal, clean, and plugin architectures. Choose a style from system forces rather than fashion.

Model business capabilities with entities, value objects, aggregates, domain services, bounded contexts, and context maps. Use domain-driven design to find boundaries that reflect real work.

Define contracts, schemas, compatibility rules, error behavior, pagination, versioning, and rate limits. Design and review REST, RPC, and GraphQL interfaces.

Document important choices with architecture decision records, diagrams, interface specifications, and operational notes. Maintain documentation that can evolve with the system.

Translate real-world concepts into entities, relationships, identifiers, constraints, and ownership boundaries. Compare normalized, denormalized, dimensional, and graph-shaped models.

Cover relational tables, indexes, query plans, transactions, isolation levels, locking, and integrity constraints. Design a transactional schema and diagnose common performance problems.

Compare key-value, document, wide-column, graph, time-series, and search-oriented databases. Select a data store by access pattern, consistency needs, scale, and operational burden.

Explain atomicity, consistency, isolation, durability, optimistic concurrency, and distributed transaction limits. Apply sagas, outbox patterns, and compensating actions when one transaction cannot span the system.

Use local caches, distributed caches, browser caches, and content delivery networks to reduce latency and load. Handle invalidation, expiration, stampedes, and stale data deliberately.

Cover processes, threads, synchronization, race conditions, deadlocks, asynchronous I/O, and parallel execution. Design safe coordination around shared state.

Use queues, publish-subscribe systems, brokers, delivery guarantees, acknowledgments, and dead-letter handling to separate producers from consumers. Build a reliable background-processing flow.

Design systems around events, event schemas, event sourcing, projections, and CQRS. Address ordering, replay, duplicate delivery, and schema evolution.

Explain partial failure, network delay, independent clocks, remote calls, and the fallacies of distributed computing. Replace unreliable assumptions with explicit protocols and failure handling.

Handle unique identifiers, logical clocks, causal ordering, idempotency, retries, deduplication, and distributed coordination. Trace how one logical operation behaves when messages arrive late or twice.

Use replication, partitioning, sharding, leader-follower designs, and quorum operations to distribute data. Plan rebalancing and recovery when machines or regions fail.

Apply strong, eventual, causal, and session consistency models. Relate CAP and PACELC trade-offs to consensus protocols, leader election, and real application behavior.

Scale services vertically and horizontally with load balancers, stateless workers, partitioning, backpressure, and admission control. Remove bottlenecks while preserving correctness.

Use latency percentiles, throughput, utilization, queueing theory, profiling, benchmarking, and load testing. Create a capacity estimate and validate it with measurements.

Design for failure with timeouts, retries, exponential backoff, circuit breakers, bulkheads, health checks, graceful degradation, and redundancy. Calculate availability targets and failure budgets.

Define backups, restore testing, recovery point objectives, recovery time objectives, failover, and regional recovery strategies. Write and rehearse a disaster-recovery plan.

Apply least privilege, defense in depth, secure defaults, segmentation, encryption, secrets management, and secure design reviews. Build a threat model using assets, trust boundaries, threats, and mitigations.

Design authentication, authorization, federation, single sign-on, service identities, role-based access, and attribute-based access. Trace identity across users, services, and administrative systems.

Map personal and sensitive data across collection, processing, retention, sharing, and deletion. Apply data minimization, consent, access controls, auditability, and regulatory constraints to architecture decisions.

Compare traditional monoliths with modular monoliths and identify module boundaries, internal interfaces, and deployment implications. Build a structure that can grow without premature distribution.

Design independently deployable services with clear ownership, decentralized data, resilient communication, and versioned contracts. Evaluate when microservices justify their operational and organizational cost.

Connect packaged applications and services through gateways, message buses, adapters, orchestration, and canonical contracts. Address workflow coordination and failures across organizational boundaries.

Assess legacy systems through dependencies, data ownership, risk, and business value. Apply strangler-fig migrations, anti-corruption layers, parallel runs, and staged replacement.

Explain virtual machines, hypervisors, images, resource isolation, virtual networks, and software-defined infrastructure. Compare virtualization with physical deployment and process-level isolation.

Design with compute, storage, managed databases, networking, identity, and regional services supplied on demand. Apply shared-responsibility, landing-zone, multi-account, and high-availability patterns.

Package applications with OCI images and run them using isolated processes, namespaces, and resource limits. Create secure, reproducible container builds and runtime configurations.

Use Kubernetes pods, deployments, services, ingress, configuration, secrets, autoscaling, and controllers. Design a cluster deployment while accounting for state, upgrades, policy, and failure recovery.

Manage service-to-service traffic with proxies, mutual TLS, traffic policies, retries, and telemetry. Decide when a service mesh solves enough problems to justify its complexity.

Build event-triggered systems from functions and managed services with automatic scaling and usage-based billing. Address cold starts, execution limits, state, observability, and vendor coupling.

Place computation and data closer to users, devices, or data sources to reduce latency and disconnected-operation risk. Design synchronization, security, and deployment across edge locations.

Represent networks, compute resources, policies, and managed services as versioned code using declarative tools such as Terraform or OpenTofu. Plan safe changes, reusable modules, state handling, and drift detection.

Connect source control, automated testing, artifact creation, deployment, feature flags, and rollback into a controlled delivery pipeline. Compare rolling, blue-green, and canary releases.

Design telemetry around logs, metrics, traces, profiles, correlation identifiers, and service-level indicators. Use OpenTelemetry-style instrumentation to follow a request across system boundaries.

Operate services with service-level objectives, error budgets, runbooks, on-call practices, incident command, and blameless reviews. Turn production failures into architectural improvements.

Protect source code, dependencies, build systems, artifact registries, and deployments from tampering. Apply software bills of materials, signing, provenance, vulnerability management, and controlled promotion.

Create shared deployment paths, templates, service catalogs, policy checks, and self-service environments for engineering teams. Treat an internal developer platform as a product with clear users and reliability goals.

Design ingestion, batch processing, warehouses, data lakes, lakehouses, catalogs, and transformation pipelines. Track lineage, data quality, schema changes, and access across an analytical platform.

Process continuous data with event-time windows, checkpoints, stateful operators, and replayable logs. Design real-time pipelines that remain correct during delays, duplicates, and restarts.

Separate tenants safely while sharing application and infrastructure resources. Address tenant-aware identity, data isolation, quotas, customization, noisy neighbors, billing, and migrations.

Coordinate browser, mobile, backend, and content-delivery components across unreliable networks and changing client versions. Design offline behavior, synchronization, session handling, and backward-compatible APIs.

Combine sensors, actuators, constrained devices, gateways, wireless links, firmware, and cloud services. Plan for power limits, intermittent connectivity, secure updates, and physical safety.

Use GPUs, specialized accelerators, memory hierarchies, parallel kernels, and high-speed interconnects for compute-heavy workloads. Match hardware topology to training, simulation, rendering, or scientific workloads.

Run portable sandboxed modules in browsers, servers, plugins, and edge environments using WebAssembly. Evaluate its security model, host interfaces, performance, and component architecture.

Design data preparation, feature pipelines, experiment tracking, training, model registries, serving, and monitoring for machine-learning systems. Account for model drift, reproducibility, feedback loops, and accelerator capacity.

Architect applications around foundation models, prompt management, retrieval-augmented generation, vector search, tool use, guardrails, evaluation, caching, and model gateways. Address hallucinations, sensitive data, latency, cost, and changing model behavior.

Estimate and control infrastructure spending through demand models, unit economics, tagging, budgets, rightsizing, scheduling, and storage lifecycle policies. Include energy use and carbon impact in major design trade-offs.

Validate designs with scenario reviews, prototypes, dependency analysis, architecture fitness functions, contract tests, load tests, resilience tests, and chaos experiments. Tie each test to a quality attribute and a measurable threshold.

Coordinate standards, review forums, reference architectures, exception handling, ownership, and technical portfolios across many teams. Balance local autonomy with security, interoperability, and long-term organizational needs.

Move systems safely through schema evolution, compatibility windows, traffic migration, data backfills, dual writes, cutovers, and decommissioning. Plan incremental change instead of relying on high-risk rewrites.

Take a realistic service from stakeholder request through requirements, quality scenarios, modeling, technology selection, security review, capacity planning, implementation guidance, validation, deployment, and operational follow-up. Deliver diagrams, decision records, risk registers, and runbooks as one coherent architecture package.

Map system architecture roles across software, cloud, security, data, infrastructure, solutions, and enterprise architecture. Build proof through design portfolios and operational case studies, evaluate relevant certifications, and stay current through standards, incident reports, technical papers, and practitioner communities.