Make your code configurable

Let teammates like PMs and marketers quickly change feature flags, in-app copy, pricing plans and more

How it works

1

Define your schema

Write a schema in GraphQL to define what parts of your code are configurable.

Use Boolean for feature flags, Int for limits, timeouts, etc, String for in-product copy, Enum for multivariate flags and custom types for more complex configuration.

2

Define your logic

Define your configuration logic with our visual, functional programming language that has A/B testing, event logging and machine learning built in.

Set up feature flag targeting, optimize prices and limits, translate and personalize copy, and manage complex content.

3

Generate code with the SDK

Install the TypeScript SDK and write a GraphQL query so it initializes with just the configuration logic you need.

Run npx hypertune to auto-generate type-safe methods you can call from any code on your frontend or backend.

Get code completion in your IDE, prevent runtime errors due to flag typos and easily find all references of flags in your codebase.

Optionally embed a build-time snapshot of your configuration logic for guaranteed, instant SDK initialization with no network latency.

4

Share with your team

Share a link to your flag with your nontechnical colleagues so they can see how it's configured and update it themselves.

Update configuration logic instantly without a code update, build, deployment, app release or service restart.

Use cases

Type-safe feature flags

  • Auto-generated type-safe code to catch flag typos and errors at compile-time instead of run-time.
  • Code completion and "find all references" in your IDE. No figuring out if your flag is in kebab-case or camelCase.
  • Type-safe enum flags you can exhaustively switch on, type-safe object and list flags, and a type-safe logic UI.
  • Pass context arguments like userId, email, etc, in a type-safe way with compiler errors if you miss or misspell one.
  • Type-safe flag clean up. Just remove it from your GraphQL query, re-run code generation and fix all the type errors in your IDE.
  • No limits on your flag logic, with a full programming language under the hood.
  • Avoid UI flickers. Embed a snapshot of your flag logic in your app bundle for instant SDK initialization with no network latency. Built for Jamstack.
  • All flags are versioned together in a single Git history for instant rollbacks to known good states. No figuring out what combination of flag changes broke your product.
Hypertune vs. other feature flag platforms

In-app content

  • Manage onboarding copy and checklists, guides and templates, tooltips and error messages, signup and upgrade flows, and modals and banners.
  • Model your content schema however you like in GraphQL. No opinionated types to learn.
  • Empower customer success, product and marketing to change in-app content themselves.
  • Insert arbitrary logic for translation, personalization, A/B testing and contextual multi-armed bandits.
  • Embed a build-time snapshot of your content logic in your app bundle for guaranteed, instant SDK initialization with no network dependency or latency.

Landing page optimization

  • A/B test your static Jamstack site, with no impact to page load time. Embed a build-time snapshot of your configuration logic — no need to add latency with server-side rendering.
  • Run full factorial multivariate tests to find the best combination of headline, subtitle, image, etc.
  • Rapidly test millions of combinations of ideas with AI to discover hidden winners.
  • Personalize your site to each unique visitor with AI, based on their referrer, device type, location, time of day, day of week, etc.
  • Powerful funnel analytics to compare conversion rates across every combination of ideas, broken down by visitor segment.
Hypertune for landing page optimization
Example logic for Landing page optimization

Pricing plans

  • Empower your growth team to manage and optimize pricing plans themselves.
  • Manage the options available to different users and the pricing logic based on their selection.
  • Manage discounts, limited time offers and promo codes.
  • Keep code clean and flexible with feature flags. Decouple the configuration logic that maps those features to plans.
  • Quickly override features and limits for specific organisations and users.

Rules and limits

  • Update product rules and limits instantly without a code update, build, deployment, app release or service restart.
  • Empower business users to update limits and rules themselves and save developers time.
  • Keep your code clean, small and flexible, expressing your core logic, not configuration details.
  • Optimize rules and limits with A/B testing and machine learning.
  • Unify rules and limits across different codebases into a single source of truth.
  • Reduce engineering complexity by separating the concerns of code and configuration.
Example logic for Rules and limits

Magic numbers

  • Manage magic numbers like pool sizes, timeouts, intervals, retry counts, backoffs, delays, sampling rates, TTLs, thresholds, limits, batch sizes, ranges, lookback periods, etc.
  • Update them instantly without a code update, build, deployment, app release or service restart.
  • Give them different values under different conditions.
  • A/B test them or automatically optimize them with machine learning.
Example logic for Magic numbers

Backend configuration

  • Configure recurring backend jobs with parameters like batch sizes, delays, timeouts, etc.
  • Platformize your backend service so others can easily add new jobs themselves.
Example logic for Backend configuration

Why make your code configurable?

  • Update logic instantly

    No need to wait for a code update, build, deployment, app release or service restart

  • Save developers time

    Empower business users to update and optimize your product themselves

  • Optimize configuration

    Optimize configuration with A/B testing and machine learning

  • Single source of truth

    Unify configuration logic across different codebases into a single source of truth

  • Improve code quality

    Make your code cleaner, smaller and more flexible

  • Reduce complexity

    Reduce engineering complexity by separating the concerns of code and configuration