Make your code configurable
Let teammates like PMs and marketers quickly change
feature flags, in-app copy, pricing plans and more
How it works
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.
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.
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.
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.
In-app content management
- 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.
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.
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.
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.
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