How to use a feature flag and A/B testing requirements checklist
A team that needs to release safely, run experiments and keep targeting data under its own control should use this checklist to compare self-hosted options before it commits to one. The most important split is between must-haves and nice-to-haves. A must-have is a requirement that would block a rollout or a compliance review if it were missing, such as role-based access, an audit trail of flag changes, or the ability to keep user attributes inside your own network. A nice-to-have improves daily work but does not change whether the platform is acceptable. Write the list down before you open any vendor page, and assign each item to one of the two groups.
Edition boundaries decide most comparisons. Across the three platforms covered here, the free self-hosted tiers and the paid self-hosted tiers differ on single sign-on, provisioning, granular roles, change requests and approval workflows, which are exactly the controls regulated teams are asked about. Licensing also varies: some code is open source, some sits under a separate enterprise license, and the terms for modifying and offering a platform as a service can differ by release. Each requirement needs a verification step. Ask the vendor to show the feature in the edition you would actually buy, and where a claim matters to an audit or a data location decision, run a proof of concept in your own environment, with your identity provider and your own network controls.
The checklist has five requirement groups, and the sections that follow take them in that order: functional must-haves covering flags, targeting, experiments and SDK coverage; hosting and data residency; identity and access; privacy and retention; and integrations, operations and support. Use each section as a set of questions you can answer for every candidate. Record who confirmed each answer, which edition and version they referred to, and whether you verified it yourself. Vendor answers that cannot be tied to a specific edition and version should be treated as open items until they are confirmed.
Functional must-haves for flags and experiments
This table compares GrowthBook, Unleash and Flagsmith on the functional capabilities a self-hosted experimentation program needs, and shows which ones sit behind paid editions. Read each row as a question to answer in a proof of concept on the exact edition you plan to run. The main takeaway is that the free self-hosted tiers cover core flag evaluation, but approvals, governance and some statistics features usually need an Enterprise license.
| Requirement | Why it matters | How to verify | Edition notes |
|---|---|---|---|
| Flag types (boolean, multivariate, percentage rollout) | Boolean kill switches, multivariate variants and percentage rollouts cover most release and test needs, and migrations often break on multivariate mapping. | Create one of each type in a test environment and confirm evaluation returns the expected variant at the expected percentage. | Flagsmith maps LaunchDarkly multivariate variations to its multivariate values. Confirm the same mapping in your target edition. |
| Targeting rules and segments | Targeting determines which users see which variant. Attributes used for targeting are often personal data, so where they are evaluated matters. | Build a segment from three attributes, test inclusion and exclusion with sample users, and confirm the rule set exports and imports cleanly. | Unleash exports segments only as references, so they must exist in the target before import. Confirm the same for any platform you choose. |
| Environments and projects | Separate environments keep staging and production configurations apart, and project limits shape how teams are organized. | Create the number of environments and projects your teams need and check that promotion between them does not overwrite production settings. | Unleash Open Source is limited to 1 project and 2 environments per instance. Plan for Enterprise if you need more. |
| Approval workflows and change requests | Approvals before a flag change reaches production are a common control expectation in regulated change management. | Require an approval on a production flag change and confirm the approver, timestamp and before and after values appear in the log. | GrowthBook's free self-hosted plan does not include approval workflows. Unleash lists change requests in Enterprise, and Flagsmith starts change requests at Scale-Up. |
| Experiment assignment and sticky bucketing | Users must see the same variant on each visit, or results are contaminated and the user experience is inconsistent. | Run an assignment test across sessions and devices and measure how many users switch variants when a rule is edited. | GrowthBook lists sticky bucketing as an Enterprise self-hosted feature. Confirm the edition before designing tests that depend on it. |
| Statistics, holdouts and safe rollouts | Holdouts measure long-term impact, and safe rollouts stop a release automatically if guardrail metrics degrade. | Configure a holdout and a guardrail metric in a sandbox and confirm the analysis output and the stop behavior. | GrowthBook's free self-hosted plan does not include holdouts or safe rollouts. Confirm whether your platform computes statistics in-house or relies on your warehouse. |
| SDK coverage for server and client | Server-side evaluation protects sensitive logic and avoids flicker, while client SDKs serve front-end experiments. | List every language and runtime in your stack, install each SDK and evaluate a flag in each, including offline or default-value behavior. | Confirm SDK licenses separately from the server license, since SDKs are often permissively licensed while the server carries a copyleft or enterprise license. |
| Flag lifecycle and cleanup | Stale flags add code complexity and risk, and auditors look for evidence that retired flags were removed or archived. | Archive a flag, check that it stops evaluating, and confirm a report lists flags with no recent evaluations or owners. | Flagsmith imports archived or deprecated LaunchDarkly flags as archived and recommends a manual check afterward. |
Which licence and edition boundaries decide the shortlist
The licence of the code and the edition that holds each feature decide which self-hosted options can meet your must-haves. GrowthBook states in its LICENSE file that code outside its enterprise directories is MIT Expat licensed, while the packages/back-end/src/enterprise, packages/front-end/enterprise and packages/shared/src/enterprise directories fall under the GrowthBook Enterprise License. Unleash moved its main repository and the unleash-server npm package from Apache 2.0 to AGPLv3 starting with v8.0.0, while its official open-source Docker images stay under Apache 2.0 and its SDKs keep permissive licenses. Flagsmith states that most of its code is BSD 3-Clause, but role-based access control, SAML single sign-on and certain database integrations are closed source and require a license.
Write each must-have as a row in your checklist and record the edition that includes it for each candidate. Single sign-on, SCIM provisioning, roles, approval workflows and change requests are where the free editions most often stop: on GrowthBook, the self-hosted Enterprise tier adds SSO, SCIM and approval workflows, while on Unleash, single sign-on, SCIM and change requests sit in Enterprise and the open-source edition is limited to one project and two environments. Confirm each of these against the vendor's current edition comparison, because feature placement changes between releases.
Confirm licence obligations with counsel before you modify the code, embed it in a product, or offer it to customers or partners as a service. The Unleash position is that running the official open-source images unmodified does not trigger the AGPLv3 source obligation, but anyone who modifies Unleash and offers it as a public or commercial service must publish the source or buy a commercial license. Record which version you will pin, since the licence terms are tied to specific releases, and ask each vendor in writing which parts of the code you would be changing.
Security requirements to write into the brief
Security requirements for a self-hosted flag and experiment platform cover who can change a flag, how that change is proven, and where keys and traffic travel. The cards below are written so a team can turn each one into a test during evaluation, not just a checkbox in a vendor questionnaire.
SSO and SCIM provisioning
Require that staff sign in through your identity provider and that accounts are created and removed automatically when people join, move or leave. On Flagsmith, SAML single sign-on sits in the Enterprise Edition, and on GrowthBook and Unleash, SSO and SCIM are Enterprise features, so the edition decision is a security decision. To verify, run a test login with a non-admin account and deprovision a test user, then confirm the platform denies access within your stated window.
Role-based access and project roles
Define which people can create flags, change targeting rules, change production environments and manage users, and map those roles to separate projects or environments. Open-source editions of Unleash are limited to basic roles, and Flagsmith role-based access control is an Enterprise feature, so confirm the roles you need exist in the edition you price. Test by signing in as each role and attempting one action outside its scope.
Audit logs of flag changes
Every change to a flag, segment, rollout percentage or environment should record who made it, when, what changed and the before and after values. Logs must be exportable and retained for the period your change management policy requires. Ask the vendor which edition includes audit logs, then verify by changing a production flag in a test environment and pulling a sample audit export that shows the old and new values.
Approval workflows for production changes
Production flag changes that alter customer-facing behavior or targeting should require a second person to review and approve before they go live. Check whether approvals are native to the platform or handled in your ticketing system, and whether the approver can be the same person as the requester. Test by requesting a change as one user, confirming it stays pending, and approving it as a different user.
Secrets and SDK key management
SDK keys and API tokens let applications read or write flag configuration, so each key should be scoped to one environment, rotatable without downtime and revocable immediately. Store admin tokens and database credentials in your secrets manager rather than in configuration files. Verify by rotating an SDK key in staging, confirming the old key fails, and checking that no key appears in logs or container images.
Encryption in transit and at rest
Require TLS on every connection between browsers, SDKs, the API and the database, and encryption at rest for the metadata store, backups and any file storage. Confirm whether your database and object storage encryption is managed by you or the cloud provider. Verify by inspecting certificates on each endpoint and checking that the database and backup volumes report encryption enabled.
Vulnerability disclosure and patch cadence
Ask for the vendor's process for receiving and fixing security reports, the versions that receive security fixes, and how fixes reach self-hosted customers. Flagsmith releases frequently, with v2.286.0 published on October 15, 2026, so your team needs a defined update window. Ask the vendor to confirm which release lines are supported and how long each one receives security patches.
Network isolation
Place the flag server, database and caching layer on private subnets, expose only the API and admin interface through a controlled ingress, and limit SDK traffic to the edge or proxy tier that serves your applications. Confirm whether the platform makes any outbound calls, such as telemetry or update checks, and whether it can run with no outbound internet access. Test by blocking egress from the server and confirming flags still evaluate.
Hosting, data residency and where targeting data travels
A single host is the simplest way to evaluate or run any of the three platforms. GrowthBook ships its Next.js front end, Express API and Python statistics engine in one Docker image and stores metadata in MongoDB or a compatible database. Unleash runs the unleashorg/unleash-server image against PostgreSQL 15 or later, with the server and admin UI on port 4242. Flagsmith supports Docker and Docker Compose quick starts, with an asynchronous task processor, optional Redis caching and optional Edge Proxies for lower latency. On all three, the SDKs evaluate flags against the server or a cached copy, so targeting attributes stay within your network as long as the SDK points at a host you run.
- Metadata database: GrowthBook uses MongoDB or a compatible database, and its documentation suggests a managed service such as MongoDB Atlas or AWS DocumentDB for production. Unleash uses PostgreSQL 15 or later. Flagsmith uses PostgreSQL with optional Redis.
- SDK evaluation: Server-side SDKs call the self-hosted API, so targeting rules run inside your network. Confirm whether each client-side SDK evaluates locally or calls back to the server.
- Experiment data: GrowthBook analyzes experiments against your own data source (BigQuery, Snowflake, Postgres, and others), runs only SELECT queries and sends only aggregated statistics back.
- Backups and file storage: GrowthBook supports local, Amazon S3 or Google Cloud Storage for file uploads, so choose the storage location deliberately.
- Single point of failure: One host carries flag delivery for every application that depends on it.
Check whether your SDKs and any telemetry settings send requests to a vendor endpoint, and document the answer before go-live.
Kubernetes deployments use the official Helm charts. GrowthBook maintains an official Helm chart and supports the same external storage options as its Docker image. Flagsmith publishes the flagsmith/flagsmith chart, which creates its own PostgreSQL server inside the cluster by default. Flagsmith's documentation recommends an externally managed database in production and offers optional PgBouncer. Unleash is deployed against a PostgreSQL 15 or later instance that you provide. In each case, the database backup, restore and patching model becomes part of the platform team's scope.
- Flagsmith database default: The bundled PostgreSQL is convenient for trials, but production guidance favors an external database with its own backup and recovery.
- GrowthBook database: Plan for a managed MongoDB-compatible service or a self-managed replica set, and confirm the data location of that service.
- Unleash database: Provide PostgreSQL 15 or later with a tested backup and restore path.
- Edge and caching layers: Unleash Edge and Flagsmith Edge Proxies sit between SDKs and the API to reduce latency. Unleash Edge's open-source version reaches end of life on December 31, 2026, so confirm the supported path before you design around it.
- Warehouse traffic: GrowthBook's queries run from the cluster to your warehouse, so network policies must allow that connection and nothing else.
Ask the vendor or your implementation partner which chart version you will pin, and who owns the database lifecycle.
OpenShift is common in regulated organizations that already standardize on Red Hat container platforms. Flagsmith runs on OpenShift through its Helm charts, but support for the Flagsmith OpenShift Operator is available only with an Enterprise plan. The same decision applies to the database: the Flagsmith chart's default in-cluster PostgreSQL is a separate workload that your security team will need to review for storage, security context and backup. GrowthBook and Unleash deployments are container-based, so the questions are about image sourcing, registry access and database placement rather than about a vendor-supported operator.
- Operator support: Flagsmith's OpenShift Operator is an Enterprise feature. Without it, you own the Helm-based installation and its upgrades.
- Image provenance: Mirror the container images into your internal registry and record the exact tags you deploy.
- Database placement: Use an externally managed PostgreSQL or MongoDB-compatible service where your policy requires it, and confirm its region.
- Security context: Review whether the chart's default settings meet your cluster's pod security rules before deployment.
- Egress: Restrict outbound traffic so that only the warehouse, identity provider and approved endpoints are reachable.
Confirm with the vendor whether any operator, support or upgrade path depends on your plan, and write that dependency into the scope.
In an air-gapped network, the platform must run without outbound internet access. The core requirements are offline container images, offline chart and package sources, local SDK evaluation and a controlled way to move flag configurations between environments. Unleash supports environment import and export as JSON, but segments and custom strategies are exported only as references, so they must exist in the target before import. Flagsmith's SDKs can be pointed at internal endpoints, and its Edge Proxies can be run inside the isolated network. GrowthBook's experiment analysis depends on a reachable warehouse, so an air-gapped GrowthBook deployment usually sits next to a warehouse inside the same enclave.
- Offline images and charts: Build an internal mirror of every image, chart and dependency, and test updates through it.
- Configuration transfer: Move flag definitions by reviewed export and import, and recreate segments before importing dependent flags.
- Experiment data: Keep the warehouse, GrowthBook server and statistics engine inside the same boundary.
- Edition limits: Confirm whether the features you need, such as SSO or change requests, are available in the edition you can license for this network.
- Telemetry: Disable or verify any outbound call from the server and SDKs, and test it from inside the isolated segment.
Ask for a written list of every outbound dependency the platform needs at install time and at run time, and test that list in the target network.
How privacy, retention and targeting attributes shape the requirements
Any user attribute that identifies a person, or singles one person out when combined with others, is personal data, and the moment it is sent to a flag service for targeting, the requirements checklist has to say so. Before comparing GrowthBook, Unleash or Flagsmith, write down every attribute the SDKs will send (user ID, email domain, account tier, country, device class and any custom context), then mark each one as sent in full, hashed, bucketed or excluded. Self-hosting keeps these values inside your infrastructure, but the SDK configuration, reverse proxies, logs and any telemetry the SDKs emit still determine what leaves the network, so confirm that list with each vendor's documentation and your own network tests.
Retention is where self-hosted platforms differ most in practice, because several stores keep personal data for different lengths of time. Ask each candidate how long exposure events, experiment results and flag change history persist, whether a deletion request for one user can remove that user's exposure records, and which role can perform it. Export files are a common gap: Unleash exports flag configurations as JSON, and an export is a copy you must govern. Warehouse query results used in GrowthBook analysis are also copies in your data platform, so set retention on those tables and on any result caches, not only on the flag database.
The data processing terms, the transfer documentation and any transfer impact assessment are your responsibility to confirm with counsel and with each vendor, and no feature flag platform removes that duty by being self-hosted. Ask vendors for their data processing addendum, the list of sub-processors and any telemetry they collect from self-hosted deployments, and record the answers in the brief. For EU and UK data, your counsel should decide whether any remaining outbound flow changes the analysis. Treat the answers as inputs to the requirements, not as assumptions to accept at procurement.
Integration requirements that determine migration effort
Integrations decide how much work a self-hosted flag and experiment platform really takes, more than the feature list does. The cards below cover the connections to check first: warehouses, SDKs, delivery pipelines, identity providers and the import paths out of LaunchDarkly or Statsig. Score each option against your own stack before you compare licenses.
Data warehouse connections
GrowthBook analyzes experiments directly against your own data source, including BigQuery, Snowflake, Redshift, Databricks, ClickHouse, Postgres, MySQL, SQL Server, Athena, Presto or Trino and Vertica, and it runs only SELECT queries. Confirm which of these your warehouse uses, who writes the metric SQL, and whether your data team can support a read-only role. Unleash and Flagsmith do not play the same analysis role, so experiment reporting may need a separate path.
SDK coverage for your runtimes
Your server languages, browser frameworks, mobile apps and edge functions each need an SDK that evaluates flags reliably. Ask each vendor for the exact list of SDKs, their maintenance status and how they behave when the server is unreachable, including the default values used. Mobile and edge runtimes often need a caching or proxy layer, so confirm whether that layer is in your edition and whether it is supported after the vendor's end-of-life dates.
CI/CD and observability hooks
Flag changes should travel through the same pipeline as code. Check whether the platform exposes an admin API for creating, changing and archiving flags from pipelines, and whether flag state changes can be sent to your monitoring tools so an on-call engineer can see when a kill switch fired. Illustrative example: a deployment pipeline that creates a flag in staging and requires a reviewer before production changes. Confirm which hooks need an Enterprise plan.
Identity provider connections
Single sign-on and user provisioning decide who can change production flags. Flagsmith lists SAML single sign-on and governance features starting at its Scale-Up plan, while Unleash lists single sign-on and SCIM provisioning under Enterprise. GrowthBook lists SSO and SCIM under its self-hosted Enterprise plan. Confirm your identity provider protocol, whether group mapping is required, and how leavers are removed from the platform.
Migration from LaunchDarkly or Statsig
GrowthBook's LaunchDarkly importer warns that advanced setups may include scenarios it cannot handle, and the application must still switch from the LaunchDarkly SDK to a GrowthBook SDK after the import. Its Statsig importer covers feature gates, dynamic configs and experiments, but metric sources and metrics are in beta and limited to warehouse-native Statsig metrics. Flagsmith's importer overwrites existing environments and flags in the target project, so run it against a test project first and check results by hand.
Export limits for Unleash and Flagsmith
Unleash exports flag configurations as JSON, but segments and custom strategies are exported only as references, so they must already exist in the target instance before import. Plan to recreate them first and test the import in a non-production environment. Unleash's migration guide recommends running both systems in parallel behind an abstraction layer before cutting over. Confirm which environments and segments your move depends on before estimating effort.
Operational requirements and how to verify them
This table lists the operational requirements a self-hosted flag platform must meet after go-live, with a verification step for each. Use it to test vendors and implementation partners on evidence, not on promises. The main takeaway: release cadence, database recovery and edge caching are the areas where teams most often discover gaps late.
| Requirement | What to confirm | How to verify before go-live |
|---|---|---|
| Upgrade cadence and release tracking | Current release lines, such as GrowthBook v5.1.0 (September 22, 2026), Unleash v8.2.0 (September 8, 2026) and Flagsmith v2.286.0 (October 15, 2026), and who tracks security fixes for your edition | Subscribe to each project's release feed, then rehearse one upgrade in staging against a copy of production data |
| Backup and restore of the metadata database | Backup schedule, retention, and whether backups cover MongoDB (GrowthBook), PostgreSQL (Unleash, Flagsmith) and attachments | Restore a backup into an isolated environment and confirm flags, segments, users and experiment definitions match |
| High availability and edge caching | Replicas for the API and database, and whether SDKs evaluate locally or call the server, including Flagsmith Edge Proxies or Unleash Edge | Simulate loss of one application node and one database node, and measure whether SDK clients keep serving cached flag values |
| Unleash Edge end-of-life for OSS users | Open-source Edge reaches end of life on December 31, 2026, and Unleash recommends OSS Edge users move to an Enterprise plan | Record the replacement path and date in your change calendar, and test the replacement in staging before the end-of-life date |
| Monitoring and alerting | Metrics for API latency, flag evaluation errors, database health, SDK connection status and experiment job failures | Trigger a controlled fault, such as a stopped database, and confirm an alert reaches the on-call channel within your target response window |
| Disaster recovery | Recovery point and recovery time targets agreed in writing, plus the location of a standby environment | Run a documented failover drill and record the actual elapsed time and any manual steps |
| Support terms after go-live | Response times, severity definitions, named escalation path, and whether upgrades and patches are included | Ask for the written support schedule and confirm which edition or retainer includes each service before signing |
| Configuration export and environment sync | How flag definitions move between staging and production, and whether segments and custom strategies must exist in the target first | Export from staging, import into a clean target, and diff the results to confirm no rules were dropped |
How to run a proof of concept before choosing a platform
This sequence turns the requirements checklist into evidence. It shows which self-hosted option meets your must-haves in your own environment, before you sign a subscription or write a partner scope.
Write must-haves with named owners
Turn each checklist item into a must-have, a nice-to-have or a deferred item, and assign one owner per line from security, data, product engineering and operations. Include hosting location, identity requirements, retention periods, required integrations and the support hours you need. The step is done when every must-have has an owner and a pass or fail test written in one sentence.
Shortlist editions that include the must-haves
Check each candidate's edition against your must-haves before any install. Feature flag vendors often place SSO, SCIM, role-based access, approvals and audit features in paid tiers, so a free self-hosted edition can fail a must-have on day one. Confirm the current edition feature list directly with each vendor, since tiers change. The output is a short list of editions, each with a written note on what it lacks.
Run a proof of concept with a representative flag set
Deploy the shortlisted editions in a non-production environment that matches your hosting model, such as your own cluster or VM. Load a representative set of flags, including boolean kill switches, percentage rollouts, multivariate flags, prerequisites and segments that reflect your real targeting. Run one real A/B test with a metric your team already trusts. The step closes when each option has a recorded result for every test case, including SDK behavior and evaluation latency.
Test SSO, audit logs and export
Connect each candidate to your identity provider and confirm group mapping, role assignment and deprovisioning for a test user. Change a flag and check that the audit log records who changed what, when, and the before and after state. Export flag configurations and confirm that segments and custom components come with them, since some exports carry references only. The step is done when a reviewer outside the project team can read the log and reproduce the export.
Rehearse a restore and an upgrade
Take a backup of the database used by the proof of concept, then restore it to a clean instance and confirm flags and experiments return with their state intact. Next, apply the vendor's current release on a copy of the instance and record every manual step, configuration change and failed check. Confirm the support window for the version you chose, because some vendors publish end-of-life dates for specific releases. The output is a restore log and an upgrade runbook draft.
Score options against the checklist
Use the must-have list from the first step as a scoring sheet. Record pass, partial or fail for each item, with the test evidence attached and the reviewer's name. Weigh hosting, identity and retention items above convenience features, and treat any failed must-have as a stop unless the owner accepts a documented workaround. The step is done when the scoring sheet is signed off by the owners named in step one.
Draft the fixed-scope requirements for a partner
Convert the scoring sheet and the test evidence into a written scope: chosen platform and edition, hosting model, integrations, migration of existing flags, security and retention controls, backup and upgrade responsibilities, and support terms after go-live. Ask any implementation partner to price against that written scope, and confirm which items are one-time work and which recur. The output is a scope document that another vendor could also quote against.
Questions buyers ask before comparing self-hosted flag platforms
What does a feature flag requirements checklist cost in effort, and what drives it?
The checklist itself is mostly internal time: product, engineering, security and data staff agreeing on which requirements are must-haves. The effort grows with the number of teams that will create flags, the number of environments, whether experiments must read from your own warehouse, and how many approval and audit rules apply. Platform licensing is a separate line. The free self-hosted editions of GrowthBook, Unleash and Flagsmith have different limits: the GrowthBook Open Source plan allows 1 project, Unleash Open Source allows 1 project and 2 environments, and Flagsmith's self-hosted open-source version has no API request limits. Governance features such as SSO, SCIM, approvals and change requests sit in paid editions, so list them as requirements early. Ask any implementation partner for a fixed-scope quote built from this list, which names deliverables and the work each one includes.
How long does a proof of concept for a self-hosted flag platform take?
The length depends on scope, and no supplied figure gives a standard duration, so confirm the estimate in writing with any partner. A narrow proof of concept covers one application, one SDK, a single environment and a few flags, and is largely a deployment and integration exercise. A broader one adds an identity provider, a database that meets your backup rules, a data source for experiment analysis and a migration test from an existing tool. Migrations take longer because each tool exports differently. GrowthBook's LaunchDarkly importer, for example, warns that advanced setups may include scenarios it cannot handle, and the application still has to switch SDKs after import. Ask for the proof of concept scope, the success criteria and the exit conditions before work starts.
What must our internal team supply before a flag platform evaluation starts?
Four groups of inputs decide whether the evaluation moves quickly. The first is identity: which identity provider will authenticate administrators, and whether SAML or OIDC is available to the platform's paid tier. The second is data access: a read-only connection to the warehouse or database that will hold experiment results, with SELECT rights, since GrowthBook runs only SELECT queries and transmits aggregated statistics. The third is environments: the hosting account, Kubernetes cluster or Docker host, the database service and the network rules. The fourth is owners: a named person for each flag category, an approver for production changes and someone responsible for retiring stale flags. Missing owners cause more delay than missing technology, so settle them before the first install.
Can our own engineers run this evaluation without an implementation partner?
Often yes for a small proof of concept. A capable platform team can start a Docker Compose or Helm-based instance, connect an SDK and test targeting rules without outside help. The risk appears when the evaluation touches production-grade hosting, identity integration, migration from another vendor, or evidence for an audit. Flagsmith's Helm chart creates its own PostgreSQL server by default, while its documentation recommends an externally managed database in production. Unleash's getting started guide requires PostgreSQL 15 or later, and its Edge caching layer's open-source version reaches end of life on December 31, 2026. Your team should decide which of these tasks it can own over the long term, since an evaluation that cannot be operated after go-live gives little useful information.
Which edition questions should we put to each flag platform vendor?
Ask for a written list of what the edition you plan to run includes, not what the marketing page implies. Confirm the following for each platform:
- Whether SSO and SCIM provisioning are in the edition you will buy, and whether they are open source or require a license
- Whether role-based access, custom roles and change requests or approval workflows are included
- Project and environment limits, and how API request limits and seat counts are billed
- Which license covers the code you will host, since GrowthBook, Unleash and Flagsmith each separate enterprise code from the core
- Support terms after go-live and the versions that will receive fixes
These answers change the total cost more than the list price does.
What changes for regulated or air-gapped flag platform deployments?
The requirements list grows in three areas. Hosting: the platform, database, cache and any Edge or proxy component must run inside your boundary, with no outbound calls you have not approved. Images and updates: you need a way to mirror container images, Helm charts and release packages into the network and to test them before promotion. Evidence: approvals, audit logs and configuration exports must be retained in a form your auditors can sample. Export and import of flag configurations is the main way to move changes between isolated environments, and segments must exist in the target before import. Confirm with each vendor which features work without internet access, and which paid features you need for approval trails. A partner can help define the boundary, but the regulator or auditor determines what evidence is sufficient.
Should we first compare GrowthBook, Unleash and Flagsmith on licensing or on features?
Start with licensing and hosting constraints, then compare features. Licensing decides what you may run and modify. GrowthBook states that code outside its enterprise directories is MIT licensed while those directories fall under its Enterprise License. Flagsmith says most of its code is BSD 3-Clause, with Enterprise features closed source. Unleash moved its source code to AGPLv3 starting with v8.0.0, while its official Docker images stay under Apache 2.0. If you modify Unleash and offer it as a public or commercial service, the AGPLv3 terms apply. Have legal counsel review the license text for your use case. After that, compare how each platform handles your required data location, identity model and experiment analysis, since those requirements eliminate options faster than feature lists do.
What does DeployOpen do during a flag platform evaluation?
DeployOpen plans, implements, integrates, hardens, documents and supports self-hosted open-source platforms inside your own cloud accounts, data centers or air-gapped networks. For a flag platform, that can include scoping the requirements, deploying a proof of concept in your environment, connecting identity and the experiment data source, and preparing the configuration and records an audit may request. DeployOpen does not issue audit reports or certifications, and it does not set the vendor's licensing terms. Most engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts, and a quote follows from that written scope. Ask for the exclusions in writing as well as the included work.
Where the checklist ends and implementation starts
Once the requirements are scored, the remaining work is fixed-scope and it is written down before anyone touches a server. The scored checklist becomes the scope: which flag evaluation path runs in your network, which identity provider and roles govern access, how the database is backed up, which integrations are built and tested, and what documentation and support terms apply after go-live. Each of those items needs an owner, a deliverable and an acceptance test. If a requirement cannot be turned into one of those, it is not yet ready to be scoped, and it should go back to the team that raised it.
Several items on a typical list sit outside the default edition and need a decision before scoping. For example, if approval workflows, SSO with SCIM or change requests are must-haves, confirm with each vendor which edition and plan include them, since GrowthBook's pricing page, Unleash's pricing page and Flagsmith's pricing page draw these lines differently. Also confirm the licence terms for the exact edition and version you plan to run. Migration from an existing tool, such as a LaunchDarkly export, is a separate deliverable with its own testing, because importers often need manual checks afterwards.
DeployOpen prepares systems, controls and evidence for compliance assessments, including access reviews, change records, backup logs and configuration baselines. It does not issue audit reports, attestations or certifications, and your independent auditor or certification body decides what the evidence proves. Security testing can be added to the scope to check the chosen setup, covering the web admin console, the flag evaluation API, SDK endpoints and the identity integration. Agree in writing whether testing happens before go-live, after it, or both, and what remediation is included in the fixed scope.
How DeployOpen scopes, delivers and supports selection and implementation
DeployOpen plans, implements, customizes, integrates, hardens, backs up, documents and supports self-hosted open-source platforms inside your own infrastructure. For feature flag and A/B testing, that means turning a requirements checklist into a written, fixed-scope plan for comparing self-hosted options and then carrying the chosen platform through to go-live.
How we scope
- Written scope lists which functional must-haves, editions and integrations are in and out of the comparison.
- Hosting, data residency and identity requirements are recorded with the owners who must approve them.
- Engagements are fixed-scope, with deliverables and timelines agreed in writing before work starts.
How we build
- Candidate platforms are installed in your cloud account, data center or air-gapped network for side-by-side evaluation.
- Targeting, rollout, experiment and access controls are tested against the requirements checklist.
- Integration points with your SDKs, data sources and identity provider are configured and verified.
How we hand over
- You receive the completed requirements matrix, edition comparison and the reasons behind the selection.
- Deployment, configuration, backup and access-control documentation is written for your own operators.
- Evidence such as configuration exports and role assignments is organized for your compliance reviewers.
How we support
- Ongoing support, upgrades and continuous testing are available as retainers after the handover.
- Upgrade planning tracks the vendor release cycle and license changes that affect your chosen edition.
- Your team can ask a partner to confirm vendor capabilities before a contract or edition change.

