5 min read
Breaking the Mold: Rethinking the Control Plane
by Albert Garcia
When KrakenD was first conceived, we weren’t interested in reinventing the wheel. We wanted to break it apart and build something better. The API gateway market was crowded with solutions clinging to centralized control plane architectures—complex, fragile systems that claimed flexibility but often left teams tangled in operational webs. At KrakenD, we asked ourselves a bold question:
How can we rethink the control plane and manage it more effectively?
This question stemmed from a genuine need to rethink the industry’s reliance on traditional control planes. In traditional systems, the control plane and the data plane are often separate components, each adding layers of complexity. KrakenD approaches this differently by integrating the control plane’s responsibilities—such as configuration, routing decisions, and orchestration—directly into its architecture. We realized that the repository, configuration, and CI/CD pipeline—all of these components are part of the control plane. Instead of removing it, we focused on managing the control plane in a more efficient way that eliminates unnecessary complexities. By leveraging immutability and GitOps, we created an approach that ensures predictable, resilient changes while minimizing complexity and risk. And here’s why it works.
A Simplified Vision: Stateless and Immutable by Design
Imagine you’re managing a fleet of airplanes. Each plane should be able to fly independently, but traditional control plane architectures insist on grounding the fleet every time you make a change to the flight plan. Worse, if the control tower goes offline, the whole operation is in jeopardy. In KrakenD’s approach, the “control tower” still exists, but instead of being a centralized, vulnerable point of failure, it’s conceptually distributed and embedded within each airplane. This means each plane has the autonomy and the flight plan embedded within, making the system resilient and efficient.
KrakenD was designed to be stateless and immutable during runtime, with each gateway instance capable of independent operation without reliance on others or a central database. Configuration is declarative and managed through version-controlled files, ensuring simplicity and stability during execution. By integrating control and data plane operations conceptually rather than treating them as separate components, configurations are managed and deployed through GitOps—making versioning and automation seamless. This approach ensures zero-downtime configuration updates, with each node able to operate smoothly even if others fail. The result? A system that prioritizes simplicity, resilience, and performance—the core values that drive everything we do at KrakenD.
The Control Plane, Done Differently
Why rethink the control plane? Let’s take a closer look at the issues we sought to resolve:
Single Point of Failure
Traditional control planes often act as the central nerve center, which makes them vulnerable to single points of failure. KrakenD’s distributed approach eliminates these vulnerabilities, ensuring that as long as one node is running, your API gateway remains operational.
Operational Complexity
Managing a control plane often means juggling multiple tools, databases, and services just to keep your gateway running. This adds overhead, introduces new attack vectors, and creates bottlenecks in deployment pipelines. By leveraging immutability and integrating control and data plane responsibilities, KrakenD minimizes that overhead, allowing teams to focus on what matters: delivering value to their users.
The Challenge of Consistency
With traditional control planes, there’s often a choice to make: should changes be ACID-compliant (using something like PostgreSQL) or eventually consistent (using a database like Cassandra)? KrakenD takes a different route—our configurations are immutable during runtime. This means you get both stability and simplicity, without worrying about inconsistent states or complicated sync processes.
The Power of Rethinking Control
By rethinking the traditional control plane and integrating it conceptually with data plane operations, KrakenD has enabled a new level of operational freedom, resilience, and scalability—removing unnecessary separation while maintaining core control capabilities. Here’s what that means for our customers:
Scalability Without Limits
Need to handle more traffic? Add more instances. KrakenD’s stateless and immutable architecture scales linearly, so there’s no need to worry about coordinating nodes or expanding databases.
Built for Engineers, By Engineers
Engineers love KrakenD because it speaks their language: clear, predictable, and focused on results. There are no black-box processes or vendor lock-ins—just lightweight, declarative configurations that work seamlessly with GitOps and other automation tools.
Peace of Mind in Production
With a reimagined control plane, there’s no central target for attackers. Our integrated approach also means compliance with regulations like GDPR or HIPAA is easier to achieve, as KrakenD doesn’t store any data.
The Future Is Stateless and Immutable
The decision to rethink the control plane wasn’t easy. It meant challenging industry norms and building a product that, at first glance, might seem unconventional. But the results speak for themselves.
KrakenD isn’t just an API gateway—it’s a rebellion against complexity. It’s a commitment to empowering developers, reducing risk, and scaling with confidence. By breaking free from the traditional challenges of control plane consistency and integration, we’ve created a solution that’s as resilient as it is elegant.
So, the next time someone tells you a control plane is essential, ask them: Why do we need a separate control plane at all? At KrakenD, we prefer to let our customers control their APIs in a way that’s simple, integrated, and effective—not the other way around.
Ready to see the difference a stateless API gateway can make? Try KrakenD.
