Infrastructure on ThecoreGrid covers the design, operation, and evolution of the foundational systems that power modern software at scale.
We explore compute, networking, and storage layers, along with virtualization, containers, and cloud platforms in highload environments. The focus is on production-grade engineering: reliability, fault tolerance, capacity planning, cost efficiency, and secure system design. Topics include Infrastructure as Code, automation, provisioning, multi-region setups, traffic routing, and failure recovery. We analyze real-world trade-offs and operational challenges, supported by BigTech practices, incident post-mortems, and lessons from large-scale infrastructure failures. You’ll find deep dives into observability, performance tuning, and platform reliability under dynamic workloads. Instead of basic setup guides, the Infrastructure tag delivers practical insights for platform engineers, DevOps teams, SREs, and architects responsible for building and maintaining robust, scalable, and efficient infrastructure systems.
In live streaming, an error is not a degradation but an instant user-facing incident. Netflix addresses this by moving quality control and prioritization directly into the origin layer. The main limitation arises where VOD approaches stop working. In live, there is no time buffer: a segment must be encoded, delivered, and cached within seconds. Any … Read more
Digital sovereignty in engineering practice boils down to a single question: how quickly can you switch providers without breaking the system? The answer is almost always determined by architecture. A system does not start to degrade at the moment a provider fails, but much earlier, when dependency on that provider becomes implicit. This shows up … Read more
When the number of containerized services grows faster than the platform team, the bottleneck is not Kubernetes itself, but its operation. Generali faced exactly this challenge—and shifted the focus from cluster management to application management. The main limitation was not performance, but operations. The microservices portfolio was expanding, multi-tenant scenarios emerged, and with them—manual scaling, … Read more
As LLM production workloads grow, it becomes clear: classic Kubernetes mechanisms do not understand the nature of inference. llm-d is an attempt to bridge this gap at the platform level. The main limitation becomes apparent when inference goes beyond a “stateless HTTP service.” Requests to LLMs have different costs: prompt length, generation phase, KV-cache hits. … Read more
When LLM becomes part of production infrastructure, traditional monitoring is no longer sufficient. The bottleneck is no longer the application code, but the routing and model selection layer — and that’s exactly where observability is needed. In LLM systems, degradation doesn’t start with HTTP endpoint failures, but with the accumulation of subtle effects: increased latency … Read more
Tansu proposes rebuilding the Kafka model: removing state from the brokers and delegating reliability to external storage. This changes the system’s behavior under load and simplifies the operational model. The problem manifests at the operational level. A classic Kafka broker is a stateful component: replication, leader elections, persistent state, long uptime. Such nodes are hard … Read more
The coregrid Radar is a weekly column where we curate key architectural insights and major releases. No need to search across multiple sources — everything in one place.
The provider update shifts the focus from convenience to predictability of behavior. This is critical when Terraform becomes the source of truth for observability configuration. The problem manifests at the state management level. In large installations, Terraform must deterministically control access and integrations. In previous versions, the behavior of monitor permissions could be non-obvious, especially … Read more
Modern systems are designed around clouds, but reliance on a single provider is beginning to manifest as a systemic risk. The issue is not the probability of failure, but its consequences and the system’s ability to survive a loss of control. The problem becomes apparent not at the latency or throughput level, but at the … Read more
AI agents complicate observability: the same request can lead to different chains of actions. Without tracing, the system becomes opaque. The problem manifests when generative systems transition from simple LLM calls to agents. An agent plans steps, invokes tools, and makes decisions dynamically. Behavior becomes non-deterministic: the same prompt can result in different call sequences … Read more
Controls: ← → to move, ↑ to rotate, ↓ to drop.
Mobile: use buttons below.