Variant AIM Server ⟫ Overview
Application Iteration Management
Your application evolves by iterating: the
(n+1)-th iteration is the
n-th iteration plus a small code delta. Managing the transition from current iteration to the next is what we call Application Iteration Management. The end goal is to mitigate the risk of code error or product misstep with code variations. Code variations instrument the candidate code path alongside the current code path with the goal of mediating user traffic between them. These temporary code bifurcations are either feature flags or experiments (A/B tests). Instrumenting code variations at scale is the hard problem we solve.
Variant AIM Server is deployed on the same network as the host application(s), either on premises or in the cloud. The server manages the instrumentation metadata, organized in the variation schemata. Each variation schema is a text file, containing complete definitions of all code variations instrumented on a particular host application. A single server instance can manage a practically unlimited number of variation schemata.
Each component of the host application that needs to participate in a code variation, communicates with Variant server via a native client library *. In addition to the client API, Variant server also exposes server-side Extension SPI, used to extend the server’s default behavior with custom, application aware semantics. Consequently, Variant AIM server provides a complete separation of instrumentation from implementation: the host application does not get littered with instrumentation-related code, which is externalized onto and managed by Variant server.
Variant AIM server is a general purpose application iteration management middleware, which makes running hundreds of concurrent experiments at one time, or conducting hundreds of production deployments daily,—a commonplace. Here’s why:
- Rich API, informed by a cogent domain model, makes the task of instrumenting and braking down new feature flags and experiments simple and risk free.
- Explicit support for concurrent code variations eliminates limitations due to mutual exclusion between code variations.
- Variant server is built with the highly scalable Scala/Akka stack and scales exceedingly well.
Middleware vs SaaS
Commercial feature rollout and experimentation management products are, under the hood, email marketing SaaS tools retrofitted with server-side bindings. This approach may work for simple use cases, but is incapable to support scale or complexity. Variant is architected from the ground up as distributed middleware, deployed on-premises or in the cloud, alongside the host application(s), which results in a massive gain in critical features, while at the same time streamlines administration and integration.
Variant empowers product owners to iterate over new product ideas through online controlled experiments, a.k.a. A/B tests. Product owners can create sophisticated experiments with unprecedented precision and ease:
- Because Variant server maintains its own user sessions, it supports tests which span multiple components of your distributed application.
- Proximity to the operational data enables easy instrumentation and analysis of tests with extended time horizon. You own your tracing data and you decide how to store it and howto join it with your operational data for analysis.
- Variant server handles targeting and qualification longevity declaratively; no coding is required to ensure that a return user sees the same experience as before or is re-evaluated.
Variant AIM middleware was developed with a developer’s frame of mind:
- Variant achieves complete separation of instrumentation from implementation by factoring out all instrumentation concerns out of the host application’s code base. Consequently, developer is relieved from writing oodles of instrumentation “code smell” in order to create code variations.
- Variant’s distributed session management offers unprecedented support for distributed host applications.
- Server-side Extension SPI provides ideal framework for code sharing and reuse between different code variations.
- There is no clunky UI to click through: feature flags can be created programmatically with a simple command line interpreter.
- Variant variation schemata are a regular development artifact and are managed with standard DevOps tools.
- Variant client is thin and discrete, requiring no additional capacity to be provisioned for the host application.
- Variant server is highly scalable and can be tuned to take full advantage of the underlying hardware.
Feature flags enable Dev Ops to leap from release trains to continuous deployment: