Update Code at Runtime
Safely and Simply.

FAANG-class dynamic configuration that's simple to debug, doesn't bypass CI/CD, and won't litter your code with stale feature flags.

Misconfigurations account for 50%+ of Software Outages

Configure & Manage

Customization / Customer Management / Compliance / Copy and Visual  / SRE / Permissioning / Coordinating / Testing / Prototyping / Self-serve in startups so far

Customization / Customer Management / Compliance / Copy and Visual / SRE / Permissioning / Coordinating / Testing / Prototyping / Self-serve in startups so far

Misconfigurations account for 50%+ of Software Outages

When the business meets engineering
Costly Incidents
  • Misconfiguration outages
  • Untested code slipped to customers
  • Undetected mistakes that lead to revenue loss
Wasted Resources
  • Responding to incidents
  • Bothering devs for simple changes
  • Cleaning up zombie feature flags
Technical Debt
  • Code littered with stale feature flags
  • Unclear webs of code paths
  • Difficulty debugging, predicting, and preventing issues

Lekko solves these problems

A new approach:
dynamic functions

In-Code Interface

Lekko wraps functions at build time to fetch updated versions at runtime. This decreases complexity with traceable code behavior.

Validate, Test, Prevent Issues

Lekko changes don't bypass unit tests, validation and CI which will prevent untested code from reaching your customers.

Group & Validate

Create approved configurations, then control who can deploy them to customers. Lekko’s Web UI lets developers hand off daily control to team members safely.

Define dynamic functions in your code.

Adding dynamic behavior is as easy as merging code with your new function. Lekko will mirror the new function, and allows you modify it at runtime.

func getGenerationParams(plan string) *LlmConfig {
	if plan == "enterprise" || plan == "team" {
		return &LlmConfig{
			Model:       "openai-chatgpt4-o",
			Temperature: 0.7,
			TokenLimit:  8192,
	return &LlmConfig{
		Model:       "openai-chatgpt3.5-turbo",
		Temperature: 1.0,
		TokenLimit:  4096,
export function getGenerationParams({ plan }: { plan: string }): LlmConfig {
    if (plan === "enterprise" || plan === "team") {
        return {
            model: "openai-chatgpt4-0",
            temperature: 0.7,
            tokenLimit: 8192,
    return {
        model: "openai-chatgpt3.5-turbo",
        temperature: 1.0,
        tokenLimit: 4096,
// Whether to use experimental features or not
func getExperimentalEnabled(env string) bool {
  if env == "staging" {
    return true
  return false
// Whether to use experimental features or not
func getExperimentalEnabled(env string) bool {
  if env == "staging" {
    return true
  return false
// Whether to use experimental features or not
func getExperimentalEnabled(env string) bool {
  if env == "staging" {
    return true
  return false

Update your code live.

Reconfigure your functions at runtime directly in your code or in our user friendly control panel. With our static analysis and AI to keep things safe, daily changes can be comfortably delegated.

Supported Frameworks
About us

Konrad Niemiec

Founder | CEO

Dynamic configuration was too powerful to go without

At Uber and Meta, we got to work on the most advanced dynamic code systems ever built.

After moving on, we were shocked how much we missed them. The right tool is transparent — you just do your work without rebuilds, customer incidents, or zombie flags that come back to kill you. Those who’ve tried to build their own tools have found it’s more complex and challenging then they imagined.

Lekko evolves Uber and Meta’s tools — which go beyond feature flags — for the broader range of companies who have more individualized relationships with the customers, clients and partners to whom they deploy their products. We think once you try it, you won’t want to work without it.

Our Background
Reduce outages

>50% of outages are the result of poorly implemented feature flags

Lower tech debt

Manage configurations with AI assisted tasks

Accelerate products

Spend less time cleaning up flags and more time writing new code

Manage risk

Keep your customers from receiving untested code


What’s a Lekko?

Named after a Polish word that means “lightly” or “easily,” a Lekko is a dynamic function that you insert into your codebase. Lekkos can be grouped, and groups can be nested. There are three classes of lekko:

  • lekko — a function that is changeable at runtime similar to a feature flag, but more broadly and easily usable.
  • validator — an accessory function that validates the contents or output of a lekko or lekkogroup.
  • Lekkoset — a group of lekkos. It can include other lekkosets.

You manage your lekkos in code or with our web application, which allow you to specify approved configurations of lekkos that can be provisioned by users with permission. Our docs show you how to get started for free.

How does dynamic configuration differ from feature flagging / management?

Dynamic configuration is a new approach to shipping quickly without having all the answers. While feature flagging is a primary use case of dynamic configuration, current feature flagging implementations carry a lot of complexity and risk. They create a tradeoff between the benefits of dynamic behavior and the downsides of complexity and technical debt.

Lekko set out to solve these problems.

Is this different from LaunchDarkly, Unleash and other feature flag tools?

While existing feature flagging tools claim to cater to engineers, they often introduce cumbersome workflows, increase the risk of bugs and outages, and impose limitations on the ways engineers can solve problems.

Lekko aims to eliminate these issues, making it easier for engineers to implement dynamic configuration and safer to hand off day to day configuration to other parts of the business.

How do you differ from experimentation tools like Statsig, Split, and Optimizely?

Lekko is not an engine for statistical testing. You can use Lekko to serve different versions of your application to different target groups and collect data, but experimentation tools like Statsig, Split, and Optimizely are designed specifically for running statistically significant A/B tests.

Why can’t I build this myself?

You absolutely can! Companies like Uber, Facebook, LinkedIn, Plaid, and Doordash have done it, investing countless hours and tens of millions of dollars in the process. Building a solid dynamic configuration system involves reading extensive research, making inevitable mistakes, and potentially developing suboptimal solutions.

Once built, you'll also need to dedicate ongoing resources to maintain and update your internal system. Alternatively, you can leverage our expertise and let us handle all of that for you. Allowing you and your team to concentrate on building better software without the overhead of managing complex configuration infrastructure.

To help you get started, we even offer a free self-hosted version of Lekko.

Our investors