Skip to content

Flagnetic documentation

  • A first flag in ten minutes: compose up, bootstrap, a project, a flag and an SDK key, evaluated from the Go or JavaScript SDK, then flipped and seen to change.
  • Installing Flagnetic: Docker Compose, Kubernetes or the binary, TLS and a reverse proxy, PostgreSQL connections.
  • Running on Kubernetes: the Helm chart, PostgreSQL, the Secret, migration modes, routes, metrics, scaling, network policy and upgrades.
  • Upgrading Flagnetic: from 0.x to 1.0, rolling upgrades between 1.x releases with the chart, Compose or systemd, what adjacent minors means, and going back.
  • Verifying a release: checking the image, the chart and each SDK package’s attestation, downloading the SBOM, and what protects Go modules.
  • Glossary: the vocabulary the code, the API, the docs and the console use.
  • Access: permissions, roles, grants, scopes and API tokens.
  • Flags: flag definitions, configurations per environment, rules, rollouts, overrides, prerequisites, the kill switch, revert, copy and compare.
  • Experiments: an experiment’s lifecycle, the rules serving it, salts and assignment, exposures, aliases across sign-up, alerts, and what a client key learns.
  • The sample-ratio check: the statistic, when it is skipped, its two thresholds, a worked example and the warehouse SQL reproducing it.
  • Governance: protected environments, which writes they refuse, and the kill switch exception.
  • Change requests: proposing a flag’s configuration for review, its diff and its states.
  • Mail: the SMTP server and setting up common relays, its TLS modes, the test mail, what is mailed and in which language, and troubleshooting by failure class.
  • Single sign-on: OIDC and SAML auth providers and setting them up with Keycloak, Entra ID, Okta and Google, their domains, group mappings, SSO enforcement, how a sign-in matches a member, and what each sign-in error means.
  • Provisioning members with SCIM: SCIM tokens, setting up Entra ID and Okta, how Users are created, adopted, updated and deprovisioned, and what a provisioned member’s directory decides.
  • Webhooks: subscribing a receiver to a project’s events, its secret, the targets the platform calls, and the event catalogue.
  • Sinks: a project’s copy of its raw events in ClickHouse, object storage or a signed webhook: configuring, guarding, testing and enabling a sink, health, failure classes, dead letters, replay, at risk and gaps, the console’s screens, metrics.
  • Exported events: the export schema and its compatibility promise, the ClickHouse DDL, the object key scheme, the webhook envelope, and a SQL recipe reproducing first exposures, the sample-ratio check and assignments.
  • Exporting and importing a project: the project document field by field and its compatibility promise, create, merge and replace, dry runs and If-Match, protection and owners, the audit trail, the console, the CLI, importing from Firebase Remote Config, and the demo project.
  • Segments and Targeting: reusable sets of conditions, and the operators and limits of every condition.
  • Operations and the configuration reference: running the server, how changes reach SDKs across replicas, and what to watch.

SDKs

  • Choosing an SDK: every SDK with its install line, mode, key, runtimes and propagation.
  • Go SDK, its OpenFeature provider, and the evaluator every Go program shares.
  • Ruby SDK: the flagnetic gem with its Rails integration and test helper, and the flagnetic-openfeature provider.
  • Python SDK: the PyPI package flagnetic, its test helper and OpenFeature provider, and how it runs under pre-forking servers and asyncio.
  • Dart and Flutter SDK: the pub.dev packages flagnetic and flagnetic_flutter, the client mode on devices and the web, the Flutter widgets, and how soon each app serves a change.
  • JavaScript SDK: the npm package flagnetic, its server mode, browser client, React bindings and OpenFeature providers, and how soon each serves a change.
  • SDK keys: server and client keys, rotation with an overlap, revocation, allowed origins, calls from browsers, and which SDKs use an environment.
  • Downloading the ruleset: the server SDK’s ruleset, its versions, conditional requests, compression and schema versions.
  • Remote evaluation: served values for a context posted by an SDK that holds no ruleset, what each key learns, and the context’s limits.
  • Events: evaluation summaries, aliases and exposures an SDK posts, each judged on its own and stored once.
  • The ruleset stream: each new ruleset version as soon as a replica has it, heartbeats, reconnection and propagation.
  • Compatibility and support: what 1.0 promises for each surface, how a deprecation is announced on the wire, which versions get fixes, and what is not a contract.
  • Versioning and compatibility: which server and schema versions each SDK version supports, and what a client key can learn.
  • Behaviour matrix: which protocol scenario each SDK passes, generated by each SDK’s own tests.
  • Implementing an SDK: the conformance suite in the order an SDK author works through it.