Show HN: Hypertune – Visual, functional, statically-typed configuration language

Hey HN! I'm Miraan, the founder at Hypertune. Hypertune lets you make your code configurable to let teammates like PMs and marketers quickly change in-app copy, feature flags, pricing plans, etc, with logic for personalization, A/B testing and ML.

It's like a CMS but instead of just letting you set static content, you can insert arbitrary logic from the UI, including A/B tests and ML.

I previously built a landing page optimization tool that let marketers define variations of their headline, CTA, cover image, etc, then used a genetic algorithm to find the best combination of them. They used my Chrome extension to define changes on DOM elements based on their unique CSS selector. But this broke when the underlying page changed and didn't work with sites that used CSS modules. Developers hated it.

I took a step back.

The problem I was trying to solve was making the page configurable by marketers in a way that developers liked. I decided to solve it from first principles and this led to Hypertune.

Here's how it works: You define a strongly typed configuration schema in GraphQL, e.g.

  type Query {
    page(language: Language!): Page!
  }

  type Page {
    headline: String!
    imageUrl: String!
    benefits: [String!]!
  }

  enum Language { English, French, Spanish }

Then marketers can configure these fields from the UI using our visual, functional, statically-typed language. The language UI is type-directed so we only show expression options that satisfy the required type of the hole in the logic tree. So for the "headline" field, you can insert a String expression or an If / Else expression that returns a String. If you insert the latter, more holes appear. This means marketers don't need to know any syntax and can't get into any invalid states. They can use arguments you define in the schema like "language" and "isReturnVisitor", and drop A/B tests and contextual multi-armed bandits anywhere in their logic.

The language is total rather than Turing-complete so programs provably terminate. And we overlay live counts on the logic tree UI so you can see how often different branches are evaluated in real time.

You get your config with low latency from our Fastly edge server, which evaluates your logic given a GraphQL query. Or via the SDK which fetches your logic once on initialization (and listens for updates), then evaluates it locally — so you can use it on your backend to get content for different users immediately, without adding latency to every request. Both GraphQL and the SDK give you auto-generated code for end-to-end type-safety based on your schema.

The SDK supports "build-time config" too, where we store a snapshot of your configuration logic in your app bundle for instant initialization. This works nicely on static Jamstack sites built with Next.JS, Gatsby, etc, as we can run A/B tests and personalization logic instantly on page load without any extra network latency.

I started building this for landing pages but realized it could be used for feature flags, in-app content, translations, onboarding flows, error messages, business rules, pricing plans, permissions, etc, as it's all just "code configuration".

Today, this configuration is hardcoded or sprawled across json/yaml files or in separate platforms for feature flags, content, etc. So if a PM wants to A/B test new onboarding content, they need to bother a developer to stitch their testing platform with their CMS, then wait for a code deployment. And is it even worth it at that point?

Our customers save time and money by buying, integrating and learning a single flexible platform rather than many separate ones.

We're still figuring out the best use cases and would love your help. What would you find Hypertune most useful for? Type-safe feature flags, content management with A/B testing, pricing plans, rules or something else? Please comment with any thoughts / questions!