UK SaaS feature flag stack 2026: Vercel Edge Config + Flags SDK vs PostHog vs Statsig

Feature flags used to be a luxury - now they're table stakes. In 2026, a UK SaaS shipping on Next.js 16 has three real options for the flag layer, and the pricing/architecture story is wildly different across them.

This guide is for UK indie hackers and small SaaS teams picking the flag stack now. We cover Vercel Edge Config + Vercel Flags SDK alone, PostHog Flags + Vercel Edge Config, and Statsig + Vercel Edge Config. With GBP pricing, UK GDPR / DUA Act 2025 residency, and Next.js 16 wiring snippets.

TL;DR

• Vercel Flags SDK + Edge Config alone if you only need kill-switches, regional toggles, and per-tenant config. Zero extra bills, sub-millisecond evaluation, no third-party PII transfer.
• Vercel Flags SDK + PostHog if you also want product analytics, session replay, and surveys on the same bill. Best free tier in the category.
• Vercel Flags SDK + Statsig if you need high-scale experimentation (CUPED, sequential testing, interaction detection) and serious A/B test stats.
• You don't need flags yet if you have under 100 paying users and ship to one segment. Wait until you're shipping risky changes or running real experiments.

The three-layer architecture

Every feature flag stack has three concerns:

1. Storage - where flag definitions live (key, rules, target audience).
2. Delivery SDK - how your app reads the flag value at request time without hitting a slow API.
3. Management UI - where you (or non-technical team members) toggle flags on/off.

The Vercel-native pattern in 2026:

Layer	Vercel-native option
Storage	Vercel Edge Config - replicated key/value at the edge, sub-millisecond reads
Delivery SDK	Vercel Flags SDK - first-party Next.js 16 integration, App Router-friendly
Management UI	Edge Config dashboard, OR a third-party (PostHog / Statsig) syncing into Edge Config

The key insight: storage and delivery are now solved. The decision is just which management UI you want, and whether you want flags bundled with analytics/experiments or kept separate.

Vercel Edge Config + Flags SDK alone

The simplest stack. No third-party flag service.

What you get

• Sub-millisecond flag reads at the edge - no network call to a flag service.
• Flag definitions live in Edge Config (a JSON-style key/value store, replicated globally).
• Toggle flags in the Vercel dashboard or via the Vercel API.
• Cohort targeting via the Flags SDK using request context (cookies, headers, geolocation).

What you give up

• No built-in A/B test stats or experiment lifecycle.
• No flag-specific analytics ("how many users saw this variant").
• No non-technical UI for toggling - your ops/product person needs Vercel dashboard access.

GBP pricing

• Edge Config is included in Vercel Hobby (free) and Pro (GBP 16/mo). 1 MB storage, 200k reads/day on Hobby. Pro and Enterprise scale.
• Vercel Flags SDK is free.

For a UK indie running 5-20 flags with a few thousand DAU, the free Hobby tier covers you forever (assuming you're allowed to use Hobby commercially - check Vercel's terms; commercial use needs Pro).

When this is enough

• Kill-switches ("disable Stripe webhooks if our database is overloaded")
• Regional toggles ("show GBP-only checkout if user country is GB")
• Per-tenant config ("enterprise tenants get the new dashboard early")
• Maintenance mode flags

If your flag use is "operational toggles", this is the right stack.

Next.js 16 wiring

// flags.ts
import { unstable_flag as flag } from '@vercel/flags/next'
import { get } from '@vercel/edge-config'

export const newDashboard = flag({
  key: 'new-dashboard',
  async decide() {
    return (await get<boolean>('new-dashboard')) ?? false
  },
})

export const ukCheckoutOnly = flag({
  key: 'uk-checkout-only',
  async decide({ headers }) {
    const country = headers.get('x-vercel-ip-country')
    if (country === 'GB') return true
    return (await get<boolean>('uk-checkout-only')) ?? false
  },
})

// app/dashboard/page.tsx
import { newDashboard } from '@/flags'

export default async function Dashboard() {
  const showNew = await newDashboard()
  return showNew ? <NewDashboard /> : <ClassicDashboard />
}

That's the whole stack. Toggle the flag in the Vercel dashboard - the change propagates globally in seconds.

Vercel Flags SDK + PostHog (the consolidation play)

If you already use PostHog (or are considering it for analytics + session replay - see our observability guide), adding flags costs you nothing.

What you get

• Everything from Edge Config alone, plus:
• Non-technical UI - product or marketing can toggle flags without dashboard access to Vercel.
• Flag analytics out of the box - "how many users were exposed to variant A, what did they do next".
• A/B test lifecycle (create variants, run, declare winner).
• All of this on the same PostHog bill that's already covering your analytics, replay, and surveys.

What you give up

• A small dependency on PostHog being up - Edge Config can act as a fallback cache so this is not a hard dependency.
• A lightweight SDK in the browser (~25 KB gzipped after lazy-load).

GBP pricing

• PostHog Free tier: 1M flag requests/mo + 100k errors + 5k recordings.
• Past free tier: pay-as-you-go - per-flag-request pricing.
• For a UK indie under 1,000 DAU running 10 flags, this is GBP 0/mo indefinitely.

How the integration works

PostHog's Vercel integration syncs flag definitions into Edge Config automatically. You author the flag in PostHog, the Vercel Flags SDK reads it from Edge Config at the edge. Zero network call to PostHog at request time.

// flags.ts
import { unstable_flag as flag } from '@vercel/flags/next'
import { get } from '@vercel/edge-config'

export const newOnboarding = flag<boolean>({
  key: 'new-onboarding',
  async decide({ headers }) {
    const userId = headers.get('x-user-id') ?? 'anonymous'
    const flagDef = await get<{ enabled: boolean; rollout: number }>('new-onboarding')
    if (!flagDef?.enabled) return false
    return hashUserId(userId) < flagDef.rollout
  },
})

PostHog handles the flag definition; your code reads from Edge Config; the rollout percentage is hashed against userId so the same user always sees the same variant.

When this is the right stack

• You already use PostHog (or plan to)
• You want analytics + flags in one bill
• You run 5-20 experiments per quarter
• Non-technical team members need to toggle things

For most UK indie hacker SaaS, this is the default 2026 stack.

Vercel Flags SDK + Statsig (the experimentation play)

Statsig is purpose-built for high-scale experimentation. If you're running 50+ experiments per quarter or need rigorous statistical methods (CUPED, Bonferroni, sequential testing), Statsig wins.

What you get

• Unlimited flag and config checks on every tier - costs scale on event volume + replay, not on flag traffic.
• Best-in-class experiment stats - CUPED variance reduction, sequential testing, automated winner detection.
• Native Vercel Edge Config integration - flag definitions sync to Edge Config, evaluation at the edge.
• Statsig SDK with sub-millisecond evaluation.

What you give up

• A second bill (vs PostHog consolidation).
• More complexity than you probably need at < 1,000 DAU.

GBP pricing

• Statsig free tier: 2M events/mo, unlimited flag checks.
• Past 2M events: per-event pricing.
• For a UK indie SaaS at 1,000-10,000 DAU running rigorous experiments, this is GBP 0-25/mo.

When Statsig wins

• You ship multiple experiments per week
• You want statistical rigor (CUPED, sequential testing)
• You have a growth or product team running structured experiment programmes
• Your scale is past 10,000 DAU

For most UK indie SaaS pre-1,000 users, Statsig is over-spec.

UK data residency under DUA Act 2025

Feature flags themselves are usually anonymous (a flag key + a rollout percentage). The complication is what context you send to the flag service to make targeting decisions.

Anonymous flags (no PII)

If your flag rules use only request context (geolocation header, A/B group hash, time of day), no PII leaves Vercel. Edge Config + Flags SDK alone is the cleanest legal posture - no third-party transfer, no sub-processor to add.

User-targeted flags (with PII)

If you want "show new dashboard to users on Pro plan in the UK", you need to pass userId, plan, country to the flag evaluator. That's personal data.

Service	UK/EU residency option	Notes
Edge Config	Vercel's edge network (US/EU/UK PoPs) - data lives where Vercel decides	Edge Config is a key/value store; no targeting beyond what's in your code. PII handling is your code's responsibility.
PostHog Flags	EU Cloud (Frankfurt) at signup	Pick EU at signup. PostHog's flag evaluation can run client-side or server-side; server-side from EU Cloud keeps data in the EU.
Statsig	EU Cloud option (paid)	EU residency on paid plans. Confirm with Statsig before signup if UK <-> US transfer is a blocker.

DUA Act 2025 angle

DUA Act 2025 exempts first-party analytics-only cookies from consent. Feature flag cookies (e.g., a sticky A/B group ID) are not analytics-only - they're for delivery. Conservative reading: feature flag cookies require consent under PECR if they persist. Solution: hash the user ID server-side and don't set a flag-specific cookie at all.

Five common UK indie hacker mistakes with feature flags

1. Adding a flag service before you need flags. If you have one product, one segment, and ship once a week, you don't need flags yet. Edge Config + a JSON file in Vercel covers it.
2. Picking the US Cloud at signup. Both PostHog and Statsig default to US Cloud unless you choose EU. UK <-> US flag context = IDTA / UK SCCs paperwork. Pick EU.
3. Flag sprawl. After 6 months you'll have 50 flags, half of them stale. Tag flags with expires metadata in Edge Config and run a monthly cleanup. The Flags SDK supports this.
4. Targeting on raw email. Don't pass email as flag context - it's PII bait. Pass a stable hash (sha256(userId + tenantId)) instead.
5. Forgetting to add the flag service to your privacy policy. PostHog and Statsig must be listed as sub-processors. See our UK SaaS legal pages template for the table.

Decision matrix

You are	Stack	Approx GBP/mo
Pre-revenue, 0-50 users, only need kill-switches	Edge Config + Flags SDK alone	£0
50-1,000 users, want flags + analytics + replay in one bill	Edge Config + Flags SDK + PostHog	£0-£15
1,000-10,000 users, want rigorous A/B test stats	Edge Config + Flags SDK + Statsig	£0-£25
10,000+ users, multiple growth experiments per week	Edge Config + Flags SDK + Statsig (paid tier)	£40+
Regulated sector (finance, health) needing strict UK residency	Edge Config + Flags SDK alone, no third-party	£0 (Hobby) or £16 (Pro)

30-minute ship-it: Vercel Edge Config + Flags SDK only

Best for UK indies who only need kill-switches and per-tenant toggles.

1. In Vercel dashboard, create an Edge Config store. Note the connection string.
2. Add EDGE_CONFIG env var to your Next.js project (Vercel auto-injects this).
3. npm install @vercel/edge-config @vercel/flags.
4. Create flags.ts with one or two flag definitions (see snippet above).
5. Use await yourFlag() in any Server Component or Route Handler.
6. Add a flag value via the Vercel dashboard or vercel edge-config CLI.
7. Deploy. Toggle the flag - watch the change propagate within seconds.
8. Add a fallback default in decide() so a missing flag doesn't crash your app.
9. Document each flag in a flags.md file in your repo with owner + expiry date.
10. Set a calendar reminder to clean up stale flags every quarter.

30-minute ship-it: Edge Config + Flags SDK + PostHog

Best for UK indies who want flags + analytics + replay on one bill.

1. Sign up at posthog.com, pick EU Cloud.
2. Install the Vercel + PostHog integration from the Vercel marketplace - this auto-syncs flag definitions into Edge Config.
3. npm install @vercel/edge-config @vercel/flags posthog-js posthog-node.
4. Create your first flag in PostHog UI with a 50% rollout.
5. Wire the flag into flags.ts - read from Edge Config, hash userId for stickiness.
6. Use await newFeature() in your Server Component.
7. Identify users in PostHog (posthog.identify(userId)) so flag-exposure events tie back to users.
8. Confirm you can see flag exposures in PostHog -> Insights -> Feature flags.
9. Add a goal metric (signup -> activation conversion) tied to the flag.
10. Run for 7 days, check stat significance, ship the winner.

30-minute ship-it: Edge Config + Flags SDK + Statsig

Best for UK indies running rigorous A/B tests at scale.

1. Sign up at statsig.com, request EU Cloud (paid plan).
2. Install the Statsig + Vercel integration from the Vercel marketplace.
3. npm install @vercel/edge-config @vercel/flags statsig-node.
4. Create your first experiment in Statsig with control + treatment + a primary metric.
5. Wire the flag into flags.ts - read from Edge Config; pass userId + traits as evaluation context.
6. Log exposure events from your Vercel route (statsig.logEvent).
7. Send conversion events from your Stripe webhook (statsig.logEvent('paid_user', amount)).
8. Watch the Statsig dashboard for daily power analysis.
9. Wait until sequential testing declares a winner.
10. Ship the winner; archive the experiment.

Frequently asked questions

Can I use the Vercel Flags SDK without Edge Config?

Yes - it works with any backing store (Postgres, Redis, plain JSON imports). Edge Config is the recommended pairing because it's free, edge-replicated, and integrates natively. For non-Vercel deployments, point the SDK at Cloudflare KV or Upstash Redis.

Is the Vercel Flags SDK locked to Vercel?

No. The Flags SDK is open source and works in any Next.js / Node environment. Edge Config is Vercel-only, but you can swap the storage backing (e.g., to Cloudflare KV) and keep the SDK pattern.

What about LaunchDarkly or Flagsmith?

LaunchDarkly is enterprise-priced. Flagsmith is open-source and self-hostable, with a fair free cloud tier. Both are real options - we focus on PostHog and Statsig because they bundle flags with adjacent products UK indies are likely already paying for.

How do I run an experiment without a flag service?

You can hash userId into A/B groups in your code and log exposures + conversions to your own database. It works but you'll spend more time on stats analysis than building the next feature. Worth it if you're regulated and can't add a third-party processor; otherwise PostHog Free covers it.

Do feature flag cookies need consent under PECR / DUA Act 2025?

Conservatively, yes - they're not analytics-only. Mitigation: don't use cookies at all. Pass userId in your auth session and hash it server-side for the flag rollout. No new cookie, no new consent.

Key takeaways

1. Vercel Edge Config + Flags SDK alone is the simplest UK indie stack - sub-millisecond reads, no third-party PII transfer, free on Hobby tier.
2. PostHog Flags + Edge Config is the default 2026 consolidation play - flags + analytics + replay + surveys on one bill, GBP 0-15/mo for typical UK indies.
3. Statsig + Edge Config wins for rigorous A/B test stats at scale - CUPED, sequential testing, unlimited flag checks; over-spec for sub-1k DAU.
4. Pick EU Cloud at signup on PostHog or Statsig to keep UK GDPR Chapter V transfers simple under DUA Act 2025.
5. Don't add a flag service before you need one - Edge Config + a JSON file covers most pre-revenue UK indie SaaS.

[!info] Want a UK-first business idea you could ship with feature flags this weekend? Every week IdeaStack publishes one deeply researched UK opportunity with real keyword data, GBP pricing benchmarks, competitor analysis, and a copy-paste builder prompt. The latest free report covers the UK Charity Soft Opt-In Compliance Toolkit (score 8.0/10).

Read the latest free report ->