Superposition, a Context Aware Configuration Management System

Facilitate safe & flexible rollout of config changes with granular configuration based on contextual data, A/B deployments, controlled rollout and rollback mechanisms

application.js
Context
Hour of the day
00:00
00:00
01:00
02:00
03:00
04:00
05:00
06:00
07:00
08:00
09:00
10:00
11:00
12:00
13:00
14:00
15:00
16:00
17:00
18:00
19:00
20:00
21:00
22:00
23:00
Vehicle Type
Auto
Cab
Bike
City
Outcome
Delhi
(20 Km)
Cab
₹ 0 / Km
Rate
0 %
Surge Factor
Total
₹ 0
Feature Packed
One Stop Solution for all your configuration needs
Superposition comes as a complete package that helps multiple teams across disciplines (front-end/back-end/operational/data) within an organization manage their configurations with a single deployment.

Typed

Enforces strict type safety and custom validation functions, preventing incorrect configuration values from being stored.

Experiments

Supports multi-variate experiments for data driven decision making and safe config releases.

Multi-tenant

Multi-tenant ready, allowing multiple teams within an organization to manage configurations with isolation in a single deployment.

UI-Support

Out of the box powerful UI to perform all configuration management activities

Rich API

All Superposition actions are backed by API end-points, enabling teams programmatic configuration changes

Performant Client

Completely in memory lookups for config with a performant async client. Clients available in Java, Python, Javascript, Go, Rust, Haskell and more...

Trusted by all development teams across
juspay_white_bgnamma_yatri_white_bg
for developers, by developers
... and more to come
main.rs 
                
                  
use cac_client;

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let client = cac_client::CLIENT_FACTORY
        .create_client(
            "dev".to_string(),
            std::time::Duration::new(10, 0),
            "http://localhost:8080".into(),
        )
        .await
        .unwrap();
    actix_web::rt::spawn(client.clone().run_polling_updates());
    let resolved_config = client
        .get_resolved_config(
            serde_json::json!({"country": "india"})
                .as_object()
                .unwrap()
                .clone(),
            None,
            cac_client::MergeStrategy::MERGE,
        )
        .await
        .unwrap();
    println!("{resolved_config:?}");

    Ok(())
}
Main.hs 
                
                  
module Main (main) where

import           Client             as CAC
import           Control.Concurrent
import           Prelude

main :: IO ()
main = do
  CAC.createCacClient "dev" 10 "http://localhost:8080" >>= case
    Left err -> putStrLn err
    Right _  -> pure ()
  threadId <- forkOS (CAC.cacStartPolling "dev")
  CAC.getCacClient "dev" >>= case
    Left err     -> putStrLn err
    Right client -> do
      resolvedConfig  <- CAC.getResolvedConfig
                           client
                           "{"country": "India"}" $
                           Nothing
  pure ()
main.go 
                
                  
package main

import (
	"fmt"
	"github.com/juspay/superposition/clients/go/cacclient"
)

func main() {
	tenant := "dev"
	pollingFrequency := 1
	cacHostName := 

	client, error := cacclient.NewCacClient(tenant, pollingFrequency, cacHostName)
	if error != nil {
		fmt.Println(error)
	}
	fmt.Println("Resolved Config => ", client.GetResolvedConfig(map[string]string{"country": "india"}, nil, cacclient.MERGE))
}
Application.java 
                
                  
import java.io.IOException;
import java.util.concurrent.CountDownLatch;
import cac_client.CacClient;
import jnr.ffi.Pointer;

public class Application {
    public static void main(String[] args) {
        CountDownLatch latch = new CountDownLatch(1);
        try {
            CacClient client = new CacClient();
            int newClient = client.cacNewClient(tenant, 1, "http://localhost:8080");
            Thread pollingThread = new Thread(() -> {
                client.startPollingUpdate(tenant);
            });
            Pointer clientPtr = client.getCacClient(tenant);
            String resolvedConfig = client.getResolvedConfig(clientPtr, "{"clientId": "abcd"}", null, "MERGE");
            System.out.println("Resolved Config: " + resolvedConfig);
        } catch (IOException e) {
            System.err.println(e.getMessage());
        }
    }
}
index.js 
                
                  
main :: IO ()
main = do
  CAC.createCacClient "dev" 10 "http://localhost:8080" >>= case
    Left err -> putStrLn err
    Right _  -> pure ()
  threadId <- forkOS (CAC.cacStartPolling "dev")
  CAC.getCacClient "dev" >>= case
    Left err     -> putStrLn err
    Right client -> do
      resolvedConfig  <- CAC.getResolvedConfig 
                           client
                           "{"country": "India"}" $ 
                           Nothing
  pure ()
main.py 
                
                  
from cacclient import CacClient , MergeStrategy

def main():
    tenant_name = "dev"
    polling_frequency = 1
    cac_host_name = "http://localhost:8080"
    cac_client = CacClient(tenant_name, polling_frequency, cac_host_name)
    cac_client.start_cac_polling_update()

    resolved_config = cac_client.get_resolved_config(dict({'country': 'India'}), MergeStrategy.MERGE)
    print(resolved_config)


if __name__=="__main__":
    main()

Superposition