Terms used in Featurevisor documentation, including feature management concepts and the tools used to work with them.

A/B test#

An experiment that compares variations of a feature by assigning users to different groups and measuring outcomes. See experiments.

Accumulating override#

A global variable override with continue: true lets later matching siblings refine the current value. Parent and child continuation apply independently. See accumulating overrides.

Activation#

An event recorded when a user is exposed to an experiment, usually including the feature key, variation and user identifier. Use an evaluation module to send it to your analytics service.

Application#

Software that uses a Featurevisor SDK to evaluate configuration, such as a website, mobile app or backend service.

Approval#

A reviewer's acceptance of a proposed change before a pull request is merged.

Archive#

Keep an entity's definition while excluding it from generated datafiles. See archiving for features, segments and attributes.

Array#

An ordered list of values, supported by the array variable type.

Assertion#

A test case that checks evaluated results against expectations for a given context and SDK state. See testing.

Attribute#

A named input used in conditions, such as country or userId, whose value comes from evaluation context. See attributes.

Authoring definitions#

The project files that people edit and review, including features, variables, segments, attributes, targets and tests. The CLI validates these definitions and compiles them into datafiles.

Boolean#

A value of true or false, used for feature flags and boolean variables.

Branch#

An independent line of development in a Git repository, used to prepare changes before merging them.

Browser#

An application such as Firefox, Chrome or Safari that runs web pages. See the browser SDK.

Bucketing#

A deterministic allocation of a user or device to a rollout or variation, based on configured identifiers. See bucketing and feature bucketing settings.

Build#

The process of compiling project definitions into datafiles for configured targets and environments. See building datafiles.

Catalog#

A searchable, read only view of definitions, relationships, tests and Git history, available locally or as a static export. See Catalog.

CDN#

A content delivery network that distributes files from servers near their consumers. A CDN is one option for hosting datafiles.

Check#

An expectation within a CLI test that compares variable values, feature results or segment membership. See checks for logical groups and error behaviour.

CI/CD#

Continuous integration tests changes automatically. Continuous deployment publishes changes after checks pass. See deployment workflows.

CLI#

The command line interface for creating, validating, testing and building a Featurevisor project. See the CLI reference.

Commit#

A recorded snapshot of changes in a Git repository, with an identifier, author and message.

Condition#

A predicate over a context attribute, segment membership, feature result or variable value. Lists mean AND, and logical groups combine the same leaves in segments, rules, force entries, root gates and overrides. See conditions.

Configuration#

Project settings in featurevisor.config.js, such as directories, environments and build options. See project configuration.

Context#

The attribute values supplied to an SDK evaluation, such as a user's identifier, country or plan. See SDK context.

Conversion goal#

An outcome used to measure an experiment, such as a purchase or completed signup. See experiment tracking.

Datafile#

A compiled JSON file containing configuration that an SDK evaluates locally. See building datafiles and loading them into an SDK.

Declarative#

Describing the intended configuration in definitions rather than implementing the evaluation logic yourself. See infrastructure as code.

Deployment#

Publishing built datafiles so applications can fetch and evaluate them. See deployment strategies.

Deprecate#

Mark a feature for removal while continuing to serve it, so SDK diagnostics can identify remaining usage. See deprecating features.

Description#

Human readable text explaining what an entity is for. See feature definitions.

Diagnostics#

Structured SDK reports about evaluation and lifecycle issues. See SDK diagnostics.

Directory#

A folder containing files or other folders, such as a project's features/ directory.

Early access#

A programme that gives customers who opt in new features before everyone else. See early access.

Entity#

A named building block of a project, such as an attribute, segment, feature, global variable or target. See the project layout.

Environment#

An optional named environment, such as staging or production, with its own configuration. See environments.

Evaluation#

Computing a feature's enabled status, variation or variable value, or a global variable value, from context and SDK state. See SDKs.

Event#

An SDK notification that an application can subscribe to, such as a context or datafile update. See SDK events.

Experiment#

A feature with variations used to compare outcomes, including A/B and multivariate tests. See experiments.

Expose#

A feature setting that keeps the feature out of datafiles, either everywhere, in some environments or for some tags. See feature exposure.

Feature#

A definition with an enabled status, rollout rules and optional variations and variables. See features.

Fetch#

An application's retrieval of a datafile before passing it to an SDK. The application owns fetching and refresh timing. See updating datafiles.

File#

A stored document containing data or code, such as a feature definition in YAML.

Flag#

A feature's boolean enabled status, often called a feature flag. See checking whether a feature is enabled.

Force#

A feature configuration that overrides normal rollout rules for matching contexts, often for testing in production. See force rules.

Git#

The version control system used to track and review changes in a Featurevisor project. See GitOps.

GitHub#

A service for hosting Git repositories, reviewing pull requests and collaborating on changes.

GitHub Actions#

GitHub's workflow automation service, which can run checks and publish datafiles. See deployment.

GitOps#

Managing configuration through versioned definitions, review and automated delivery from Git. See GitOps.

Global variable#

An independently evaluated typed configuration value defined under variables/, with its own overrides and requirements. See global variables for configuration that does not belong to a feature.

Hash#

A deterministic value calculated from input data. Featurevisor uses hashing for consistent allocation. See bucketing.

Holdout#

Users deliberately kept out of every experiment, so that comparing them with everyone else shows the combined effect of the experiments. See holdouts.

Instance#

An initialized SDK object holding a datafile, context and optional sticky state. See SDK initialization.

Integer#

A whole number variable type. See integer variables.

Interval#

The time between repeated datafile fetches scheduled by an application. See updating datafiles.

JavaScript#

The language used by the Featurevisor CLI and the universal JavaScript SDK, which runs in browsers and Node.js.

JSON#

JavaScript Object Notation, the data format used for compiled datafiles and an optional format for authored definitions.

Key#

The identifier of an entity or a named item within it, such as a rule or variable. Entity keys derive from their file paths. See namespaces.

Kill switch#

A way to turn a feature, or a whole flow, off for everyone without a release, such as a force entry or a boolean global variable. See kill switches.

Level#

The severity associated with diagnostic output, such as a warning or error. See diagnostics.

Lint#

Validate definitions and their relationships before building or deploying them. See linting.

Logging#

Recording diagnostic information for troubleshooting evaluation or lifecycle issues. See SDK diagnostics.

Merge#

Combine changes from one Git branch into another, usually after review and automated checks.

Module#

An application SDK extension with lifecycle, evaluation or bucketing callbacks. See modules.

Multivariate test#

An experiment comparing combinations of several variable values. See A/B and multivariate tests.

Mutation#

A partial change to a variable value, such as setting a nested property or appending an array item. See mutations.

Mutually exclusive#

Experiments arranged so a user cannot participate in more than one of them at a time. See mutually exclusive experiments.

Name#

An informal synonym for an entity's key, such as a feature name.

Native apps#

Applications built for a particular platform, such as iOS or Android. See the available SDKs.

Node.js#

A JavaScript runtime for servers and command line tools, including the Featurevisor CLI. See the Node.js SDK.

npm#

The package manager used to distribute Featurevisor's JavaScript packages. See CLI installation.

Number#

A numeric variable type for whole and fractional values. See number variables.

Object#

A variable value containing named properties, which can themselves have nested schemas. See object variables.

Operator#

A comparison such as equals or in, used in conditions, requirements and checks. See operators.

Override#

A targeted replacement or refinement of a value. See feature variable overrides, variation overrides and global variable overrides.

Package#

A separately distributed component, such as the CLI or a language SDK. See SDK packages.

Parser#

The component that reads authored definitions, using YAML by default or another configured format. See custom parsers.

Percentage#

The portion of a rollout rule's audience allocated to a feature, from 0 to 100. See progressive delivery.

Pretty#

Formatted JSON with whitespace for readability. See pretty datafiles and pretty state files.

Production#

The environment where real users access an application. See environments.

Project#

A collection of Featurevisor definitions and tests, usually maintained in a Git repository. See the quick start.

Promotion#

Copying definitions between sets, such as from staging to production. See promotions.

Pull request#

A proposal to merge repository changes, with a place for discussion, review and automated checks. See GitOps.

Push#

Upload local commits to a remote Git repository.

QA#

Quality assurance: checking that application behaviour meets expectations before exposing changes to users. See testing in production.

Ready#

An SDK can evaluate as soon as a datafile has been set on the instance, without a separate readiness step. See initialization.

Refresh#

Fetch a new datafile and set it on an SDK instance without restarting the application. See updating datafiles.

Repository#

The versioned files and history of a project. A Featurevisor repository holds its definitions and configuration.

Required features#

A feature leaf in conditions that compares another feature's enabled status, variation or both. A feature with expose: false stays out of datafiles, so do not hide one that others require. See feature requirements.

Required variable#

A predicate over an evaluated global or feature variable, optionally at a nested path. It is separate from a schema's required properties. See variable requirements.

Requirement#

A prerequisite declared through conditions, optionally using boolean groups. Conditions can also select segments, rules, force entries and overrides. See conditions for all four leaf kinds.

Review#

A peer's assessment of proposed changes before approval or a request for revisions.

Revision#

An incrementing build identifier included in generated datafiles so applications can identify the configuration they use. See building datafiles.

Rule#

A feature's targeting conditions and rollout percentage, optionally scoped to an environment. See rollout rules.

Runtime override program#

Compiled global variable operations evaluated by an SDK, generated from authored overrides and mutations. See mutation precomputation.

Scenario#

A CLI test without a single owning entity, defined through root checks and optional context, matrices, targets and child cases. See scenario testing.

Schema#

The expected type and structure of a variable value. See schemas.

Schema version#

The format version of a compiled datafile, distinct from package versions and build revisions. See datafiles.

Scope#

Context that one part of a React or Vue page adds, such as the product it shows, through FeaturevisorScope. Every hook or composable below it evaluates with that context merged over the instance's. See React scopes and Vue scopes.

SDK#

A software development kit that evaluates a datafile locally in an application. The application handles fetching and refreshing. See SDK guides.

Segment#

A reusable group of conditions for selecting an audience. See segments.

Set#

An independent definition tree within a project, useful for release lanes or distinct applications. See sets and promotions.

Site#

The earlier static project view, replaced by Catalog. See Site history for older projects and Catalog for the current interface.

Staging#

An environment for testing changes before production. See environments.

State files#

Versioned records of variation allocations and the revision, used when building datafiles. See state files.

Status#

An automated check result attached to a commit or pull request, often used to require successful tests before merging. See CI/CD.

Sticky#

Feature results or global variable values supplied to an SDK instance that take precedence over normal evaluation. See sticky state.

String#

A text value supported by the string variable type.

Tag#

A label on a feature or global variable that targets can use to select datafile contents. See tags.

Target#

A definition under targets/ that selects the features and global variables for a datafile, optionally applying known context during building. See targets.

Terminal#

An application for entering shell commands, such as commands from the CLI reference.

Testing#

Evaluating definitions against declared expectations before applying configuration changes. See testing for feature, segment and global variable specs.

Tracking#

Sending experiment exposures and outcomes to an analytics service so results can be measured. See evaluation modules and Google Analytics tracking.

Usage#

The places where another entity is referenced, useful when changing or retiring definitions. See finding usage.

Value#

The result of an evaluation, such as an enabled status, variation or variable value. See SDK evaluation.

Variable#

A typed value an SDK reads. A feature variable belongs to a feature and follows its rules and variations. A global variable stands on its own.

Variation#

A named alternative within a feature, used to assign different experiences in an experiment. See variations.

Weight#

A variation's share of the users a rule lets in, distinct from the rule's own percentage. See values and weights.

YAML#

A human readable data format used by default for Featurevisor definitions. See custom parsers for other authoring formats.