IC1 — DNS (Domain Name System) Maps human-readable hostnames to IP addresses. The global distributed cache that makes the internet addressable. DNS propagation delay (TTL) determines how quickly a change to an IP address is visible to all clients. Absent: Services cannot be addressed by name; changes to IP addresses require all clients to be updated simultaneously.
IC2 — CDN (Content Delivery Network) Caches static or cacheable content at edge nodes geographically close to users. Serves cached responses without reaching the origin, reducing latency and origin load. Absent: All requests reach the origin; global users experience round-trip latency to a centralised datacenter; origin bandwidth costs scale with total traffic.
IC3 — Load Balancer Distributes incoming requests across multiple instances of a service. Performs health checks and removes unhealthy instances from the pool. Layer 4 (TCP/IP) balancers make routing decisions based on connection information; Layer 7 (HTTP) balancers can route based on URL path, headers, or payload content. Absent: All traffic hits one instance; no horizontal scaling; one instance failure causes full unavailability.
IC4 — API Gateway Single entry point for all external API traffic. Handles cross-cutting concerns: authentication, rate limiting, request routing, TLS termination, request/response transformation, and observability (access logs, distributed trace injection). Absent: Every service must implement authentication, rate limiting, and TLS independently; no unified observability of external traffic.
IC5 — Service Mesh Per-service sidecar proxies that handle service-to-service communication. Provides mTLS (mutual TLS between services), retries, circuit breaking, timeouts, and distributed tracing without requiring application code changes. Absent: Service-to-service security and resilience patterns must be implemented in application code; changes to resilience policies require code changes and redeployment.
IC6 — Rate Limiter Restricts the request rate per client, per endpoint, or per resource. Prevents a single client from consuming disproportionate capacity. Implemented with token bucket, leaky bucket, or sliding window algorithms. Absent: A single misbehaving client can consume all available capacity; FM3 (Unbounded Resource Consumption) is guaranteed under adversarial or buggy client behaviour.
IC7 — Application Server The stateless compute layer. Receives requests, executes business logic, and returns responses. Stateless so that any instance can handle any request, enabling horizontal scaling. Absent: No place to run business logic; stateful servers are the alternative but require sticky routing and coordination.
IC8 — Background Worker Executes tasks asynchronously. Pulls work from a queue (IC13), executes it, and acknowledges completion. Decouples the time of task creation from the time of task execution. Absent: Long-running operations must be synchronous, blocking the caller; no retry mechanism for failed operations.
IC9 — Cache Server In-memory key-value store. Extremely fast reads and writes (microseconds vs milliseconds for disk). Reduces load on slower persistent stores by serving frequently accessed data from memory. Absent: All reads hit the primary database; read latency is bounded by database latency; database load scales with read traffic rather than write traffic.
IC10 — Synchronous RPC / REST A direct request-response call between services. The caller waits for the response. Simple to reason about; creates a latency dependency on the callee. Absent: Services cannot call each other; no composition of services is possible.
IC11 — Service Discovery Maintains a registry of available service instances and their addresses. Clients query the registry to find a healthy instance rather than hardcoding addresses. Absent: Service instances must have static, known addresses; scaling (adding instances) requires clients to be updated; instance failures require manual configuration changes.
IC12 — Relational Database (SQL) Stores structured data in tables with defined schemas. Supports ACID transactions (Atomicity, Consistency, Isolation, Durability). Strong consistency model. Structured Query Language (SQL) for flexible querying. Absent: No transactional consistency; no relational queries; ad-hoc data retrieval requires full scans.
IC13 — Message Queue / Event Stream Durable ordered log. Producers append messages; consumers read at their own pace, tracking their position (offset). Decouples producers from consumers. Supports replay. Absent: Synchronous coupling between producers and consumers; a slow consumer blocks a fast producer; no replay for re-processing or event sourcing.
IC14 — NoSQL Document Store Stores semi-structured documents (JSON, BSON). Schema-flexible: different documents in the same collection can have different fields. Horizontal sharding built in. Trades relational queries for scale. Absent: Schema evolution in relational databases requires migrations; document stores allow field addition without migration for flexible schemas.
IC15 — Key-Value Store Maps keys to values. O(1) reads and writes. No relational structure, no range queries (hash partitioning). The data model is maximally simple; the performance is maximally predictable. Absent: The simplest data access pattern (get by key, put by key) requires a full database with more overhead than necessary.
IC16 — Wide-Column Store Rows identified by a partition key; rows within a partition sorted by a clustering key. Supports efficient range queries within a partition. Designed for horizontal sharding at the table level. Examples: Apache Cassandra, Google Bigtable. Absent: Time-series and write-heavy workloads require workarounds in relational or document stores that limit throughput.
IC17 — Object Storage Stores arbitrary binary objects (files, images, videos, backups) with HTTP-accessible URLs. Infinitely scalable, cheap per GB, eventually consistent. Not a file system — no directories, no atomic multi-file operations. Absent: Large binary assets must be stored in databases (expensive) or on file system (not horizontally scalable).
IC18 — Search Index Inverted index structure optimised for full-text search. Supports ranked retrieval, fuzzy matching, and field-level filtering. Examples: Elasticsearch, OpenSearch, Apache Solr. Absent: Full-text search requires full-table scans; relevance ranking is unavailable.
IC19 — Vector Database Stores dense vector embeddings. Supports approximate nearest-neighbour queries (find the k most similar vectors). Enables semantic search, recommendation, and similarity matching. Examples: Pinecone, Weaviate, Qdrant, pgvector. Absent: Semantic similarity queries require embedding computation and full-scan comparison at query time; infeasible at scale.
IC20 — Batch Processor Processes large datasets in bounded jobs. Read all data → transform → write results. High throughput, high latency (minutes to hours). Correctness-first: processes data to completion before results are visible. Absent: Large-scale data transformation must happen incrementally or in real time; neither is appropriate for all workloads.
IC21 — Stream Processor Processes unbounded event streams continuously. Applies transformations, aggregations, and joins to data as it arrives. Low latency (seconds to milliseconds). Complexity-first: managing state across a continuous stream requires careful design. Absent: Real-time aggregations and alerts are not possible; all event processing must be batch (minutes to hours latency).
IC22 — Metrics System Collects, stores, and queries numeric time-series data. Counters, gauges, and histograms. Supports alerting when values exceed thresholds. Examples: Prometheus, Datadog, CloudWatch Metrics. Absent: No ability to answer “what is the error rate right now?” or “how has latency changed since the deploy?”; SLO enforcement is impossible.
IC23 — Log Aggregator Collects structured log output from all services, indexes it, and makes it queryable. Supports correlation of events across services by request ID or trace ID. Examples: Elasticsearch + Kibana (ELK), Splunk, Loki. Absent: Debugging requires SSH access to individual service instances; logs are lost on container restart; no cross-service correlation.
IC24 — Distributed Tracing Tracks the path of a single request across multiple services. Each service adds a span to the trace; the trace visualises the call graph and per-service latency. Examples: Jaeger, Zipkin, AWS X-Ray, Honeycomb. Absent: The latency of a multi-service request cannot be attributed to individual services; the bottleneck in a complex call chain is invisible.
IC25 — Configuration Management Stores and distributes configuration to services without requiring a redeploy. Supports environment-specific configuration, secrets management, and feature flags. Examples: AWS Parameter Store, HashiCorp Vault, LaunchDarkly. Absent: Configuration changes require code changes and redeployment; secrets are stored in environment variables or source code (security risk); feature flag rollouts require deployments.
IC26 — Orchestrator / Scheduler Manages the deployment and lifecycle of containerised services. Handles scaling, health checking, rolling updates, and resource allocation. Examples: Kubernetes, ECS, Nomad. Absent: Service deployment is manual; scaling is manual; resource allocation is manual; failures require manual intervention.