Serverless platforms and modern cloud environments allow teams to ship software fast, but they also add complexity. Engineers must manage sprawling infrastructure, multiple config formats, and coordinate changes across tools that rarely work smoothly together. This creates operational drag at a time when speed matters most.
Twain Taylor, editor at Software Plaza, recently spoke with Pablo Barón, co-founder and CEO of Platform Engineering Labs, about these challenges and how Formae aims to resolve deep-rooted issues in DevOps and Ops. Their conversation highlighted a growing consensus: many platform engineering problems stem from outdated configuration formats and the surrounding tooling. YAML and JSON were once convenient, but today they slow down teams working at scale. Formae solves this by replacing brittle configuration files with codified functionality built on PKL.
This article explains why this shift matters, how Formae’s architecture leads to safer and more efficient workflows, and why codification is becoming the next logical step in platform engineering.
Why conventional configuration formats hold platform teams back
YAML and JSON became popular because they are simple and easy for machines to parse. Over time, they became the default configuration formats for Kubernetes, CI/CD pipelines, and countless tools. As platform engineering evolved, however, its flaws became impossible to ignore.
Indentation and formatting errors remain a constant source of production issues. YAML’s whitespace sensitivity and lack of strict schemas make it easy to break things accidentally. JSON avoids some pitfalls, but it still forces engineers to manually rewrite the same configuration patterns repeatedly, which gets old fast. A little programmability would eliminate these repetitive tasks entirely.
The deeper issue is that these formats were built for machines, not humans. When that mismatch shows up inside real teams, it turns everyday infrastructure work into busywork. Engineers end up dealing with low-level details they should not have to manage, like storage sizing, encryption settings, and networking parameters. Config files quickly grow into messy, thousand-line documents held together by whatever tools people could find.
As organizations scale, these problems multiply. Outages become more likely, changes move slower, and configuration files become bottlenecks instead of helpers. What once seemed simple has turned into a major operational limitation.
How classic IaC tools complicate truth management
Infrastructure as code brought much-needed structure and repeatability, but some of its core mechanisms now slow teams down. Terraform is still widely used, but its approach to reconciling desired state with real infrastructure introduces serious challenges.
Each Terraform run creates a state file, a second source of truth that easily falls out of sync with both the code and the actual cloud environment. Teams then have to manage plans, applies, refreshes, and locks just to keep that state file accurate. When something breaks, figuring out whether the code, the state file, or the cloud environment is at fault becomes a real headache.
A stale state file can lead to destructive actions or completely miss important changes. Collaboration becomes difficult when multiple engineers need to work on the same state. Merging infrastructure updates across branches often turns into a logistical nightmare.
Many teams try to work around these problems using managed backends or stricter workflows, but the core model remains fragile.
Shift from configuration to codification
To move beyond the limits of YAML, JSON, and state-file-driven IaC, platform engineering needs more than configuration. It needs codification.
Configuration only describes what an environment should look like. Codification adds intelligence, structure, and guardrails. It enables teams to define infrastructure using constructs like loops and conditionals without the complexity of full programming languages.
Codification lets platform teams describe systems the way they naturally think about them. Instead of repeating the same configuration everywhere, they can create shared modules that handle common tasks. Instead of forcing developers to specify low-level details, they can expose simplified inputs tailored to the application.
Most importantly, codification supports multi-level abstraction. Senior engineers build reusable, deeply engineered components. Developers consume simplified versions without needing to understand every detail. This reduces cognitive load and speeds up delivery. Formae exists to make this codification approach practical at scale.
Introducing Formae: a new model for platform engineering
Formae rethinks how teams define, sync, and manage infrastructure. It is built around two key ideas: active convergence and distributed awareness.
Instead of relying on the outdated plan-and-apply routine, Formae uses a live backend that works continuously with distributed agents. The backend tracks all known resources and their relationships. Agents discover new resources, monitor changes from any tool, and ensure the desired state defined in code stays accurate.
This brings several advantages:
- Eliminates fragile state files.
- Syncs instantly with changes from Terraform, Pulumi, Crossplane, or ClickOps.
- Provides continuous convergence instead of manual cycles.
- Supports diverse tooling across multiple teams.
Engineers can keep using their preferred tools while Formae ensures consistency, versioning, and safety.
PKL: the human-friendly infrastructure language
PKL, created at Apple, is Formae’s primary interface. It is clear, typed, and much more forgiving than YAML or JSON. PKL includes loops, conditionals, schemas, and a readable syntax that prevents common structural errors.
Aspect | YAML/JSON | PKL (in Formae) |
Human readability | Low | High |
Error prevention | None | Strong typing and schemas |
Abstraction | Limited | First-class support |
Logic support | None | Loops and conditionals |
Drift handling | External tools | Built-in convergence |
PKL provides the flexibility of a programming language without overwhelming developers. Since Formae executes PKL directly, the platform converges infrastructure exactly as declared, with no extra steps that can modify behavior.
Multi-layer abstraction for platform and developer workflows
Formae enables layered abstractions that simplify operations. Platform teams define the deep infrastructure details in PKL. Developers consume simplified versions, choosing from options like small, medium, or large instead of complex parameters.
This clear separation of responsibility reduces cognitive load and speeds up delivery.
What Formae means for the future of platform engineering
With Formae, engineers can update a single field on a resource without touching anything else. Patches are versioned automatically and added to the system’s understanding of state. Formae also tracks manual changes made through cloud dashboards, treating them as patches instead of ignoring or overwriting them. This reduces risk, accelerates fixes, and provides an easy-to-follow history.
By moving away from brittle YAML and JSON and toward codification, Formae delivers safer abstractions, clearer role boundaries, and faster workflows. Eliminating state files and embracing active convergence solves long-standing operational pain points. Check out the podcast to learn more about how Formae is changing the future of platform engineering.
Platform engineering needs tools that reduce complexity rather than increase it. Formae provides a path to modernize infrastructure operations and help teams scale with confidence.
