Skip to main content
📬 Get weekly Production AI insightsPractical notes on Kubernetes, AI infrastructure and platform engineering. No spam.Subscribe free
Platform Engineering

Fun with Flags: OpenFeature at the Amsterdam JUG, Hosted by Flagsmith

Amsterdam JUG at Flagsmith: Simon Schrottner on OpenFeature. Providers against lock-in, evaluation context for targeting, hooks + OpenTelemetry for old flags.

Luca Berton

¡ The Production AI Expert

Published ¡8 min read

Tonight the Amsterdam Java User Group met at Flagsmith, on the Plantage Kerklaan. It was a loft with plants everywhere, bikes on the wall, folding chairs and good pizza. The host could not have fit the first talk better: a feature-flag company hosting a talk about the open standard for feature flags.

Luca Berton with Simon Schrottner of Flagsmith before the talk, Simon in a feature-toggle T-shirt.

I caught up with Simon Schrottner before he went on. He wore a T-shirt with a toggle switch on it, which was a good sign for a talk called “Fun with Flags: How OpenFeature Solves Your Feature Flag Headaches.” Simon is a Fractional Developer Advocate at Flagsmith, an OpenFeature maintainer and a CNCF Ambassador. What follows is my write-up of his talk, with my own notes from the platform side.

This was not our first conversation about flags. At Dutch Cloud Native Day in Utrecht I recorded a short interview with Simon for Udienza: OpenFeature and AI at runtime, episode 104. In three and a half minutes he explains why feature flags matter more now that AI can change systems at runtime: the flags define the boundaries inside which an AI is allowed to change a system. He also explains why a production bug becomes a fix on Monday instead of a Friday evening. The talk tonight is the long version of that conversation.

Simon Schrottner opens “Fun with Flags” in front of the Flagsmith banner at the Amsterdam JUG.

Half a billion dollars in one hour

Simon opened with the story every feature-flag talk should start with. A trading firm lost half a billion USD in one hour because of a feature flag. They had repurposed an old flag: an old flag name now switched on new code, and one server still ran the old code. (Simon’s reference was Statsig’s write-up, How to lose half a billion dollars, about Knight Capital in 2012.)

Slide: “What happened — lost half a billion USD, in one hour, due to a feature flag they repurposed.”

The point is not that flags are dangerous. The point is that a flag is production configuration with a lifecycle. If you treat it as a throwaway if, it stays in the code long after you forget it.

Not every flag is the same flag

Simon used Pete Hodgson’s classification from martinfowler.com. Flags differ in two dimensions: longevity (days to years) and dynamism (changes with a deployment, with a runtime re-configuration, or with each request).

  • Release toggles live for days or weeks and change with a deployment.
  • Ops toggles (kill switches) can live for years.
  • Experiment toggles change with each request.
  • Permission toggles are long-lived and per-user.

Slide: “Categories of Feature Flags” on longevity and dynamism axes — release, ops, experiment and permission toggles.

This is the slide I would show any team that says “we just need a boolean.” A release toggle and a permission toggle need very different tools and very different clean-up rules.

A glorified conditional, until it isn’t

The next slide was the most honest one of the evening. At the start you see a glorified conditional: a boolean, if (flag) { newThing() }, and the question “how hard can it be?” Later you discover vendor lock-in, dynamic targeting and experiments, stale and obsolete flags, observability gaps, brittle string keys, and lifecycle and governance.

Slide: “At the start, you see a glorified conditional… Later you discover vendor lock-in, dynamic targeting, stale flags, observability gaps, brittle string keys, lifecycle and governance.”

Simon’s “Homegrown” slide said it in three steps: early, a quick win (ten lines of code); later, complexity creeps in (each service rolls its own, with no central UI, no targeting, and flags that duplicate, drift and rot); eventually, you built a platform (API, UI, targeting, observability). “Congratulations, you’re a vendor.”

I see the same pattern in platform engineering all the time. Every internal tool that is not a product becomes one by accident. The fix is the same as for logs, metrics and traces: standardise the interface and let the back end be replaceable.

OpenFeature: one API, many providers

That is what OpenFeature is. It is a vendor-neutral, CNCF-hosted specification and a set of SDKs for feature-flag evaluation. Simon showed a short history:

  • May 2022: announced at KubeCon Valencia by a group of flag-vendor engineers, who invited the community to contribute.
  • June 2022: accepted into the CNCF Sandbox.
  • November 2023: promoted to CNCF Incubating, with a stable spec and 1.0 SDKs for the major languages.
  • Today: a collaborative, multi-vendor standard with broad adoption.

Slide: “A short history — May 2022 KubeCon Valencia, June 2022 CNCF Sandbox, Nov 2023 CNCF Incubating, today a multi-vendor standard.”

The rest of the talk followed three problems, and one OpenFeature concept for each.

Problem 1: vendor lock-in. Concept: providers

The Evaluation API is the part your code calls: one API, many languages, never breaks your code. Behind it sits a provider, which is the adapter to the actual flag source. That source can be a JSON file, flagd, Flagsmith, or a commercial vendor. You change the provider and the application code stays the same.

Slide: “Concept: Providers” — your app calls the feature-flagging client; the provider talks to the flags service.

The design choice I liked most: the default is mandatory. Every evaluation call takes a fallback, so the SDK always returns something:

boolean on = client.getBooleanValue("v2_enabled", false);
//                                                ^^^^^ the fallback, not optional

The provider is unreachable? You get false. The flag key has a typo? The fallback wins. The flag returns a string where you asked for a boolean? The fallback wins. The rule engine throws? The fallback wins. Your code path always has a value to work with. For anyone who has seen a flag service outage take down a checkout, this is the most important line in the spec.

Slide: “The default is mandatory” — provider unreachable, flag key missing, type mismatch, evaluation error: the fallback wins.

Simon then showed the same flag in a UI: Flagsmith’s self-hosted dashboard instead of a JSON file, with the same OpenFeature call on the client. The flag source is an implementation detail.

Slide: “The same flag — in a UI”: the Flagsmith dashboard managing the same flag, with the same OpenFeature SDK call on the client.

In Java, the setup is short:

OpenFeatureAPI api = OpenFeatureAPI.getInstance();
api.setProviderAndWait(provider); // flagd, Flagsmith, or any other vendor's provider

Client client = api.getClient("checkout");
boolean on = client.getBooleanValue("v2_enabled", false);

Problem 2: dynamic evaluation. Concept: evaluation context

Targeting needs data: who the user is, which tenant, which region. OpenFeature calls this the evaluation context: dynamic evaluation, deterministic targeting, reduce blast radius. You set the context where the data actually lives: globally, per request (transaction), per client, or per call.

// global: true for every evaluation
api.setEvaluationContext(new MutableContext().add("region", "eu"));

// client: scoped to one domain
Client client = api.getClient("checkout");
client.setEvaluationContext(new MutableContext().add("domain", "checkout"));

// invocation: per call
client.getBooleanValue("v2_enabled", false, new MutableContext("user-42"));

The contexts are merged in a fixed order: API (global) → transaction → client → invocation → before hooks. Later stages override earlier ones, so the context of a call wins over the global default.

Slide: “Merge Order” — API (global), transaction, client, invocation, before hooks. Later stages override earlier ones.

Problem 3: obsolete flags. Concept: hooks and OpenTelemetry

You cannot remove a flag if you do not know whether anyone still evaluates it. OpenFeature gives you hooks around every evaluation: a before stage, the evaluation, then an after or error stage, and always a finally stage.

Slide: “Flag Evaluation Life-Cycle” — before stage, flag evaluation, after or error stage, finally stage.

This is where my observability side got interested. The community maintains ready-made OpenTelemetry hooks for Java, Node.js, Go, Python, .NET and more, in the open-feature/<lang>-sdk-contrib repositories. Add the hook and every evaluation emits signals that follow the OTel semantic conventions for feature flags:

  • Traces: a span event per evaluation, attached to the current span, with the flag key, the provider and the chosen variant, plus error details on failure.
  • Metrics: total evaluation calls, success and error counts, and an active evaluations counter.

Slide: “Hooks + OpenTelemetry = observability for free” — traces and metrics for every flag evaluation.

“Observability for free” is the right title. Once flag evaluations are in your traces, two hard questions become dashboard queries: which variant did this failing request get? and has anyone evaluated this flag in the last 30 days? The second question is how you find obsolete flags and remove them safely, before one gets repurposed by mistake.

What I take home

Slide: “What we covered” — Evaluation API; vendor lock-in → providers; dynamic evaluation → evaluation context; obsolete flags → hooks + OpenTelemetry.

My summary for platform teams:

  1. Put feature flags behind a standard interface now, even if you have only one vendor or a homegrown system. OpenFeature costs very little, and it keeps the option to change providers.
  2. Always use a safe default. OpenFeature forces you to, which is a good reason to use it.
  3. Treat flag evaluations as telemetry. Add the OpenTelemetry hook in the platform’s base image or starter, so every team gets it without asking. It is the same idea as OpenTelemetry on Kubernetes: the standard is the pipeline, the back end is a choice.
  4. Give every flag an owner and an expiry. The type of flag (release, ops, experiment, permission) tells you how long it should live.

Simon closed with an invitation to join: #openfeature on the CNCF Slack, github.com/open-feature, the community page and the public community meetings. The maintainers label good first issues on GitHub, so it is an easy project to start contributing to. For the short version before you start, watch my Udienza interview with Simon; openfeature.dev is the place to begin.

The rest of the evening

After Simon, Željko Kozina (Chronomill) gave “No Country For Old APIs,” about wrapping legacy Java REST and SOAP services as MCP tools without a rewrite. He quoted Martin Fowler (“the only thing a Big Bang rewrite guarantees is a Big Bang”) and argued for a GraphQL facade between the MCP server and the legacy estate, with hand-written tools built with Spring AI’s @McpTool. One data point from his slides stayed with me: tool-selection accuracy drops below 90% somewhere between 10 and 30 tools, depending on the model. More tools is not better. I wrote up his talk in full, with GraphQL, tool search and his open-source GATool starters: No Country for Old APIs. The last talk of the evening was Sarah Gruneisen (Xebia) with “When Silence Becomes a Security Vulnerability,” about how a vulnerability can start when someone notices a weak signal and does not speak up. Her five-layer model puts human safety at the bottom, under technical controls; my write-up of her talk is here.

Željko Kozina presents “No Country For Old APIs” at the Amsterdam JUG at Flagsmith, with a full room.

Thanks to Flagsmith for the venue and the pizza, to Simon, Željko and Sarah for the talks, and to Geertjan Wielenga and the Amsterdam JUG team for another excellent evening. If you want to speak at a future meetup, the JUG takes proposals at amsterdamjug@googlegroups.com.

More Amsterdam JUG write-ups: Project Valhalla at Trifork and @Retryable at Doctolib.

Free 30-min Production AI consultation

Book Now