Skip to main content

Introducing Health Check-informed Upgrades

· 6 min read
Sapphire Mason-Brown
Engineer @ Syntasso

What does confidence in an upgrade look like? Seeing an upgrade applied? Seeing that something is running at the expected version? Or is it knowing that something is healthy following an upgrade? In the latest version of SKE, v0.63.0, we've introduced health-informed upgrades. Now, an upgrade only moves on when your Resource Requests pass their Health Checks.


When GitOps explodes in your face

· 9 min read
Derik Evangelista
Engineer @ Syntasso

We love GitOps.

Kratix, a framework for building platforms on top of Kubernetes, has GitOps at its core, and it's a fundamental part of our recommended platform architecture. It’s what allows Kratix to schedule workloads to any type of Destination, what enables Compound Promises, and a central piece of the declare-and-converge philosophy we follow.

But what happens when hundreds of commits are pushed in a short period? Or when customers want to know "who did that?", but the answer is buried under thousands of automated commits? Or even when you can't commit to the repository at all?

In this blog, we will cover how our health checks turned a GitOps repository into a commit firehose, why switching to buckets was not enough, and how the new Health Source in SKE puts the Platform back in control.


Rebuilding Our Backstage Integration for Platform Adoption

· 9 min read
Derik Evangelista
Engineer @ Syntasso

We at Syntasso are very proud of the SKE Backstage integration we built. You apply a Promise, and a Component and a Template automagically appear in your Backstage instance. You can send requests to the platform via GitOps or directly via the Kubernetes API. Changes to the Promise regenerate the Template. You can use an array of CRD properties to control the validation applied to the form, and you can run custom containers to customise what the platform generates.

It is great.

Except, it kinda looks like this:

The original Resource page in Backstage, showing the resource status as raw YAML

Which is enough to get you started, but it won't necessarily wow the platform users. It solved the immediate problem for the platform engineer (how do I expose this service on Backstage?), but it was quite simple on the visual front. Apparently raw YAML is not everyone's cup of tea… not sure why. it better.

In this post, we will explore why the interface matters and how it can drive adoption of your platform. We'll look at what we had before, what we have learned from our customers, and how we used that learning to improve the out-of-the-box experience with Backstage. We will then look at what we have just released to make it even better.


Manage Files in Dynamically Registered Git Repositories

· 6 min read
Jake Klein
Engineer @ Syntasso

Application repositories contain much more than application code. Platform teams often need to manage agent instructions, linter configuration, CI workflows, security policies, dependency rules, or service catalogue metadata.

Making the first commit is the easy part. The real challenge comes later, when the organisation changes its standards. Someone then needs to find every repository, update the right files, correct manual drift, and remove files that are no longer required.

A Kratix Promise can own that complete lifecycle. The user identifies their Git repository and describes what they need. The Promise generates the desired files, and Kratix schedules them to that repository. When the platform team updates the Promise, Kratix rolls the change out to the repositories it manages. It also corrects drift and removes the managed files when their Resource requests are deleted.

The files become managed platform resources, not the forgotten output of a one-off scaffolding task.


Sharing resources: a claims pattern for Compound Promises

· 10 min read
Derik Evangelista
Engineer @ Syntasso

If you have been writing Compound Promises, you have probably wondered: what happens when multiple resources need to share one unique resource provided by a sub-Promise?

For example, imagine an Application Promise that deploys applications on Kubernetes. Each application may need a namespace on the destination cluster, so you make it a Compound Promise and use the Namespace Promise from the Marketplace. You know the drill: the Application Promise's configure pipeline writes the Namespace request to /kratix/output/, Kratix schedules it to the Platform cluster, and the Namespace Promise does its thing.

You request your first application, app-one, in the team-mobile namespace. The pipelines run, you see the Namespace request come through, the namespace appears on the destination, shortly followed by the application. So far, so good. You now want to deploy a second application, app-two, also in team-mobile. You send the request, the pipeline runs, and... nothing happens.

You check your GitOps agent logs and see that you now have two requests for the same Namespace. It does not like that. You update your Promise pipeline to only emit the Namespace request if it does not exist yet. Everything seems to work, until you delete app-one, the original requester of the Namespace. As the Namespace request is owned by app-one, it gets deleted. app-two, deployed in that namespace, gets wiped out in the process. Absolute chaos.

Congratulations: you have discovered that work ownership and shared resources are not friends.

In this post we walk through a Promise design that fixes this. We call it claims, and there is a working example in the Marketplace.


Kratix Workflow Controls: Easily Manual Approvals to Your Platform

· 6 min read
Cat Morris
Product Manager @ Syntasso

Modern platforms do not operate in isolation. They depend on manual approvals, external systems, the availability of other resources, and compound building blocks. Until now, modelling these asynchronous processes in Kratix has been inelegant, and the underlying Kubernetes pods orchestrating the tasks could remain alive for a long time.


Refactoring Kratix Logs: introducing log levels

· 8 min read
Derik Evangelista
Engineer @ Syntasso

Making our controllers more observable is something we have been working on for a while. The first step in the journey was to introduce more descriptive and consistent status and events across all Kratix-owned resources (for example, check the Promise status and events). Together with additional printer columns for the kubectl get command, this represented a great improvement to the user experience of operating a platform that uses Kratix.

side note: I often say destination statuses were the best feature we ever implemented in Kratix. Time has been proving me right:

Chunyi agrees

The next problem we wanted to tackle was logs. Whenever an error occurred, our customers would need to go through a painful journey sifting through hundreds of lines of logs to attempt to find the one line that contained the right error. Kratix output a range of logs at different levels, all unstructured. We often caught ourselves on customer support calls just to point out to them that the error is right there, line 5675 of the logs. We needed to do better.

So back in June 2025 the team at Syntasso got together to explore how we could make discovering what went wrong when their platform is not behaving the way they expected easier. The results of that session were a series of guidelines and best practices for logging that we should follow when building out controllers. In this blog post, we will go through those guidelines, how we implemented them, and the results we have seen so far.


Control your Fleet Upgrades with Kratix Promise Revisions and Resource Bindings

· 5 min read
Cat Morris
Product Manager @ Syntasso

Rolling out changes across a platform fleet is one of the hardest parts of being a platform engineer. Move too fast, and you risk availability. Move too slowly, and the platform becomes a bottleneck.

Imagine you are responsible for maintaining a suite of production services. Some support apps that are more business critical than others - maybe they are customer facing, or back time-sensitive business functions. You receive a notification of a vulnerability that you need to patch. How do you ensure that upgrades to those business critical services are successful and won’t cause downtime or outages?


Best practices for Promise-writing

· 14 min read
Sapphire Mason-Brown
Engineer @ Syntasso

As platforms are so unique to organisations, and the services required by platform users are so vast, Kratix has always been very flexible when it comes to the design of Promises. Other than the expectation that Promise writers honour the Promise schema, the scope for how Promises can be designed is vast; containers can be written in any language, workflows can be as segmented as you would like and workflow actions can be imperative or declarative.

However, there are a number design practices and approaches to Promise development that can make development and maintenance easier for Promise developers and make consuming services via Promises better for users.

In this blog post, we're going design a Promise with some core fundamentals in mind, paving the way for improved debugging, reliability and user clarity.


Introducing the Kratix Promise-writing SDKs: Faster, Easier, More Testable

· 5 min read
Cat Morris
Product Manager @ Syntasso
New feature? WOW!

These SDKs excel at everything from bootstrapping the initial Promise for your organisation's platform to ensuring consistency and testability across all the Promises your platform teams create.

Defining and building platform APIs and services is no easy task in general. Platform engineers who adopt Kratix and create bespoke services – which we call “Promises” – often encounter a significant "wall of bash" when starting their journey towards taming their underlying IaC config, YAML, and API calls.