Build Blog
Building Infrastructure from the Inside Out: Our Work on the Linux Kernel and Cilium
At Build, we believe the quality of infrastructure underneath determines the reliability of everything running on top. Here is how our work on the Linux kernel and Cilium shapes the platform.
Most developers do not think about networking until something breaks.
Packets drop. Latency spikes. A service that worked fine in staging behaves differently in production. And somewhere underneath the application, deep in the infrastructure layer, something is routing traffic in a way that no one fully understands.
This is the layer most platforms abstract away and hope you never have to look at. At Build, we dig into these problems. We believe that the quality of the infrastructure underneath directly determines the reliability, performance, and security of everything running on top of it. That belief shapes who we hire, how we build, and what we are able to offer teams that depend on us.
The Infrastructure Layer Most Teams Never See
Cloud-native networking is one of the most complex and consequential parts of modern infrastructure.
As applications move from monoliths to distributed systems, the network becomes the connective tissue holding everything together. Services communicate constantly. Traffic needs to be routed efficiently, secured at the connection level, and observable enough that teams can diagnose problems when they arise.
Getting this right requires expertise that goes far below the application layer. It requires understanding how the Linux kernel handles network packets, how eBPF programs intercept and process traffic at the kernel level, and how tools like Cilium translate those low-level capabilities into practical networking primitives for cloud-native environments.
Most platforms do not have engineers who work at this level. Build does.
Introducing Lex Siegel
We are proud to introduce Lex Siegel, founder of Build.
Lex founded Build with a rare combination of low-level systems expertise and cloud-native networking experience that directly shapes how the platform is designed and operated. He is a Linux kernel contributor with hands-on experience working at the boundaries of where operating systems meet networking, and a contributor to Cilium, the open-source cloud-native networking and security project built on eBPF.
Cilium has become one of the most important projects in the cloud-native ecosystem. It provides networking, observability, and security for Kubernetes environments using eBPF to enforce policies and route traffic at the kernel level, without the overhead of traditional approaches. Contributing to a project of that complexity requires a deep understanding of both the technology and the ecosystem around it.
Lex's work at that level is not incidental to what Build does. It is foundational.
Why Kernel-Level Expertise Matters for a Platform Like Build
When teams deploy on Build, they are trusting us with the infrastructure layer they never see.
That trust has to be earned through the quality of the systems underneath. Networking is one of the most critical of those systems. How traffic is routed between services, how connections are secured, how network policies are enforced, and how the platform handles traffic at scale are all questions that get answered at the kernel and infrastructure level long before any application code runs.
Linux kernel contributors work at the core of what is possible with the underlying system. They understand not just how to use the abstractions that operating systems provide, but how those abstractions are built and where they break down. That knowledge is directly applicable to building infrastructure that is reliable under pressure, performant at scale, and secure by design.
For a managed platform that handles deployments for teams operating at significant scale, this expertise is not a nice-to-have. It is a requirement.
Cilium and the Future of Cloud-Native Networking
Cilium represents one of the most significant shifts in how cloud-native networking is implemented.
Traditional networking approaches in Kubernetes relied on iptables, a kernel-level packet filtering system that works but does not scale cleanly and offers limited observability. As clusters grew larger and traffic patterns became more complex, the limitations of iptables became increasingly apparent.
Cilium addresses these limitations by using eBPF, a technology that allows programs to run safely inside the Linux kernel without modifying kernel source code. This enables networking policies to be enforced with significantly lower overhead, deeper observability into traffic flows, and more flexible routing capabilities than traditional approaches allow.
For teams running high-throughput workloads, the difference is measurable. Less networking overhead means more capacity for application traffic. Better observability means faster diagnosis when something goes wrong. More flexible policy enforcement means security can be applied precisely without blunt-instrument approaches that create unintended friction.
Lex's contributions to Cilium reflect an understanding of these tradeoffs at the implementation level. That understanding shapes how Build thinks about networking infrastructure and how we approach the problems that matter most to teams operating at scale.
What This Means for Teams Building on Build
The expertise that Lex and the broader Build team bring to cloud-native networking has direct implications for what teams experience when they deploy on the platform.
Environments that behave consistently and predictably, even under load, are a product of infrastructure designed with a deep understanding of how networking actually works. Low-latency service communication, reliable traffic routing, and security policies that enforce without creating performance bottlenecks are all downstream effects of getting the networking layer right.
Teams building on Build do not need to understand eBPF or contribute to the Linux kernel to benefit from the work happening at that level. They just need environments that work reliably, scale cleanly, and behave the same way in production as they do in development.
That is what infrastructure expertise is for. Not to be visible, but to make everything above it work better.
Building with the Right Foundation
At Build, we believe that the teams that move fastest are the ones with the most reliable foundations underneath them.
Cloud-native networking is one of the hardest parts of that foundation to get right. It requires expertise that most platform teams do not have in-house, applied to problems that most developers should never have to think about directly.
Having Lex Siegel, Build's founder, bringing Linux kernel and Cilium contributions to the core of how the platform is built means that the foundation Build provides is built with genuine depth. Not assembled from off-the-shelf components and good intentions, but designed by someone who understands the systems at the level required to make them trustworthy.
That is the kind of platform we are building. And it is the kind of platform that teams running serious workloads deserve to build on.