diff --git a/.env.example b/.env.example
index d0a5c51d..cfa1b07a 100644
--- a/.env.example
+++ b/.env.example
@@ -14,3 +14,23 @@ VAPID_SUBJECT=mailto:support@example.com
 # from /api/settings/branding/logo/... with CDN-style immutable cache headers
 # (fine for local dev and CI).
 BLOB_READ_WRITE_TOKEN=
+
+# ---------------------------------------------------------------------------
+# Error tracking & crash reporting (Sentry)
+# ---------------------------------------------------------------------------
+# See docs/ERROR_TRACKING.md for setup, grouping, sourcemaps, privacy, and
+# alert rules for critical errors.
+#
+# NEXT_PUBLIC_SENTRY_DSN: client-side DSN used by the browser SDK. Leave empty
+# to disable error reporting (e.g. local dev and CI). This value is public.
+NEXT_PUBLIC_SENTRY_DSN=
+
+# SENTRY_ORG / SENTRY_PROJECT: used by the Sentry CLI/Webpack plugin to upload
+# sourcemaps during the build so stack traces are readable.
+SENTRY_ORG=
+SENTRY_PROJECT=
+
+# SENTRY_AUTH_TOKEN: server-only token with `project:releases` scope for
+# sourcemap uploads. Never expose this to the client. Leave empty to skip
+# sourcemap upload (builds still succeed, traces will be minified).
+SENTRY_AUTH_TOKEN=
\ No newline at end of file
diff --git a/docs/ACCESSIBILITY.md b/docs/ACCESSIBILITY.md
index e82b2510..6b42e749 100644
--- a/docs/ACCESSIBILITY.md
+++ b/docs/ACCESSIBILITY.md
@@ -53,6 +53,31 @@ The initial audit surfaced the following categories of critical/serious violatio
 - **Browser coverage locally vs. CI.** A fresh dev sandbox may only have the Chromium Playwright browser installed. CI installs Chromium, Firefox, and WebKit via `npx playwright install --with-deps`, so the merge gate is multi-engine even when a local run (`npx playwright test --grep @a11y`) only exercises Chromium.
 - **Moderate/minor axe findings are not gated on.** Only `critical`/`serious` impact violations fail the build, per the acceptance criteria. Any moderate/minor findings surfaced by axe during a run are not currently tracked separately.
 
+## Breadcrumbs and contextual help
+
+The breadcrumb navigation (`src/components/Breadcrumbs.tsx`) and contextual help system (`src/components/HelpTooltip.tsx`) are covered by the same axe gate and have an explicit accessibility contract:
+
+### Breadcrumbs
+
+- Rendered as a `<nav aria-label="Breadcrumb">` landmark so screen readers can jump to it.
+- The trail is an ordered list (`<ol>`); each crumb is an `<li>`.
+- The current page is marked with `aria-current="page"` on its link/text and is not itself a link target.
+- Separators are decorative (`aria-hidden="true"`) so they are not announced.
+- Every crumb is a real focusable link (or plain text for the current page) reachable in DOM order via Tab.
+
+### Contextual help (`HelpTooltip`)
+
+- The trigger is a `<button type="button">` with an accessible name (`aria-label`, e.g. "Help: Invoice status") — never an icon-only element without a label.
+- The help text is associated with the trigger via `aria-describedby` pointing at the tooltip content element, so the description is announced when the trigger receives focus.
+- The tooltip opens on focus **and** hover, and closes on `Escape` and on blur, so keyboard-only users can read and dismiss it without a pointer.
+- The tooltip content is exposed in the accessibility tree (not `aria-hidden`) while open; it uses `role="tooltip"` and is referenced by the trigger's `aria-describedby`.
+- Tooltip text must meet 4.5:1 contrast against its background in both light and dark themes.
+
+### Audit scope notes
+
+- The breadcrumb and help-tooltip components are exercised on the audited routes listed above (they render in the shared layout / page headers). Any new route that mounts them inherits coverage automatically once added to the `PAGES` array.
+- When adding a new `HelpTooltip`, verify: (1) the trigger has a non-empty accessible name, (2) `aria-describedby` resolves to an element that exists in the DOM, and (3) the tooltip is dismissible with `Escape`. These are the failure modes axe and the keyboard interaction tests are most likely to catch.
+
 ## Extending the audit
 
 To add a new page to the gate, add an entry to the `PAGES` array in `e2e/a11y.spec.ts` — the shared `runAxe()` helper and assertion are reused automatically. For flows that require user interaction (opening a modal, completing a multi-step form), follow the pattern in the two targeted tests at the bottom of that file: drive the interaction with Playwright, then call `runAxe(page)` and assert on `critical`/`serious` violations.
diff --git a/docs/FEATURE_FLAGS.md b/docs/FEATURE_FLAGS.md
new file mode 100644
index 00000000..2d122616
--- /dev/null
+++ b/docs/FEATURE_FLAGS.md
@@ -0,0 +1,127 @@
+# Feature Flags
+
+This document describes how feature flags are used in this project to control feature rollout, testing, and experimentation. It covers the flag lifecycle, naming conventions, rollout percentages, A/B testing, analytics, and cleanup.
+
+## Overview
+
+Feature flags (also called feature toggles) let us ship code without immediately exposing it to all users. They allow us to:
+
+- Roll out features gradually to a percentage of users
+- Test features with internal users before public release
+- Run A/B tests to measure the impact of changes
+- Disable a feature quickly if something goes wrong, without a redeploy
+
+## Feature Flag Service
+
+We use a hosted feature flag service that provides:
+
+- A dashboard UI for creating and toggling flags
+- Server-side and client-side SDKs for flag evaluation
+- Targeting rules (by user ID, percentage, attributes)
+- Built-in analytics and experiment support
+
+Flag evaluation is cached locally by the SDK, so evaluating a flag has negligible performance impact. Flags are evaluated once per request/session where possible and results are memoized.
+
+## Flag Lifecycle
+
+Every flag moves through the following stages:
+
+1. **Proposed** — A flag is requested in the issue tracker with a name, owner, and purpose.
+2. **Created** — The flag is created in the flag service dashboard, defaulting to `off` in production.
+3. **Development** — The flag is enabled for internal/test users only while the feature is built.
+4. **Rollout** — The flag is enabled for a growing percentage of users (see [Rollout Percentages](#rollout-percentages)).
+5. **Full rollout** — The flag is enabled for 100% of users.
+6. **Cleanup** — The flag and its dead code paths are removed (see [Cleanup](#cleanup)).
+
+Each flag must have an **owner** and a **target cleanup date** recorded in the flag service description.
+
+## Naming Conventions
+
+Flag names must be lowercase, hyphen-separated, and follow this pattern:
+
+```
+<area>-<feature>-<variant>
+```
+
+Examples:
+
+- `checkout-one-click-payment`
+- `search-vector-ranking`
+- `profile-avatar-upload`
+
+Rules:
+
+- Use a stable, descriptive name — never rename a flag after it has shipped; create a new one instead.
+- Prefix experimental flags with `exp-` (e.g. `exp-onboarding-tour`).
+- Prefix kill-switch flags with `kill-` (e.g. `kill-recommendations`).
+- Keep names short but unambiguous; avoid abbreviations that are not widely understood.
+
+## Rollout Percentages
+
+Gradual rollout uses percentage-based targeting. Recommended progression:
+
+| Stage | Audience | Duration (guideline) |
+|-------|----------|----------------------|
+| Internal | Team members only | Until feature is stable |
+| Canary | 1% of users | 1–2 days |
+| Early | 5% of users | 2–3 days |
+| Growing | 25% of users | 3–5 days |
+| Majority | 50% of users | 3–5 days |
+| Full | 100% of users | — |
+
+Guidelines:
+
+- Percentage targeting must be **sticky** — a given user should consistently fall into the same bucket. Use a stable bucketing key (e.g. user ID) rather than random sampling per request.
+- Monitor error rates, latency, and key business metrics at each stage before increasing the percentage.
+- If metrics regress, roll back to the previous percentage immediately.
+- Never jump directly from 0% to 100% for user-facing features unless the change is trivial.
+
+## A/B Testing
+
+A/B tests use the same flag infrastructure with experiment support:
+
+1. Define the experiment in the flag service with named variants (e.g. `control`, `treatment`).
+2. Assign a stable bucketing key so users see a consistent variant.
+3. Expose the variant to the application via flag evaluation.
+4. Track exposure and conversion events through the analytics integration (see [Analytics](#analytics)).
+5. Run the experiment for a pre-determined duration and sample size; do not peek and stop early.
+6. Record the result and decision in the experiment description, then clean up.
+
+Experiments must have a hypothesis, a primary metric, and a defined success threshold before launch.
+
+## Analytics
+
+Flag evaluations and experiment exposures are tracked automatically:
+
+- **Exposure events** are emitted when a user is evaluated for an experiment flag, including the flag key and variant.
+- **Conversion events** are emitted by application code at the relevant action points.
+- Events are sent to our analytics pipeline and are available in the flag service dashboard.
+
+Do not emit exposure events for simple on/off rollout flags unless you need to measure adoption. Avoid logging personally identifiable information in flag events.
+
+## Cleanup
+
+Flags are temporary. To keep the codebase healthy:
+
+- Every flag must have a target cleanup date when created.
+- Once a flag is at 100% (or an experiment has concluded), open a cleanup task to:
+  1. Remove the flag from the flag service.
+  2. Remove the flag evaluation code and any dead branches.
+  3. Remove associated tests that only exist for the flag.
+  4. Update this document if the flag was referenced.
+- Flags older than their cleanup date are reported in the weekly engineering review.
+
+## Performance
+
+Flag evaluation is designed to have no measurable performance impact:
+
+- The SDK caches flag configurations locally and refreshes them in the background.
+- Evaluations are in-memory lookups.
+- Results are memoized per request where appropriate.
+
+If you suspect a flag is causing a performance issue, check the SDK's diagnostics and report it to the platform team.
+
+## Related Documentation
+
+- [User Guide](USER_GUIDE.md) — end-user documentation, including how to manage feature flags in the UI.
+- [Contributing Guide](../CONTRIBUTING.md) — development workflow and flag-related contribution guidelines.
\ No newline at end of file
diff --git a/instrumentation-client.ts b/instrumentation-client.ts
index 4566ad69..7bdf6bd5 100644
--- a/instrumentation-client.ts
+++ b/instrumentation-client.ts
@@ -2,6 +2,89 @@ import * as Sentry from "@sentry/nextjs";
 
 const dsn = process.env.NEXT_PUBLIC_SENTRY_DSN;
 
+/**
+ * Keys that may contain personally identifiable information.
+ * These are scrubbed from event payloads before they are sent to Sentry.
+ */
+const PII_KEYS = [
+  "email",
+  "phone",
+  "name",
+  "firstName",
+  "lastName",
+  "address",
+  "ip",
+  "ipAddress",
+  "wallet",
+  "walletAddress",
+  "publicKey",
+  "privateKey",
+  "secret",
+  "password",
+  "token",
+  "authorization",
+  "cookie",
+];
+
+const REDACTED = "[REDACTED]";
+
+function scrubValue(value: unknown, depth = 0): unknown {
+  if (depth > 8 || value == null) {
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => scrubValue(item, depth + 1));
+  }
+
+  if (typeof value === "object") {
+    const result: Record<string, unknown> = {};
+    for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
+      if (PII_KEYS.some((piiKey) => key.toLowerCase() === piiKey.toLowerCase())) {
+        result[key] = REDACTED;
+      } else {
+        result[key] = scrubValue(val, depth + 1);
+      }
+    }
+    return result;
+  }
+
+  return value;
+}
+
+function scrubEvent(event: Sentry.ErrorEvent): Sentry.ErrorEvent | null {
+  if (event.user) {
+    // Only keep the hashed wallet identifier; drop everything else.
+    event.user = event.user.id ? { id: event.user.id } : {};
+  }
+
+  if (event.request) {
+    delete event.request.cookies;
+    delete event.request.headers;
+    delete event.request.data;
+    delete event.request.query_string;
+  }
+
+  if (event.extra) {
+    event.extra = scrubValue(event.extra) as Record<string, unknown>;
+  }
+
+  if (event.contexts) {
+    event.contexts = scrubValue(event.contexts) as typeof event.contexts;
+  }
+
+  if (event.breadcrumbs) {
+    event.breadcrumbs = event.breadcrumbs.map((breadcrumb) => ({
+      ...breadcrumb,
+      data: breadcrumb.data
+        ? (scrubValue(breadcrumb.data) as Record<string, unknown>)
+        : breadcrumb.data,
+    }));
+  }
+
+  return event;
+}
+
 if (dsn) {
   Sentry.init({
     dsn,
@@ -9,7 +92,37 @@ if (dsn) {
     debug: false,
     replaysOnErrorSampleRate: 1.0,
     replaysSessionSampleRate: 0.0,
+    integrations: [
+      Sentry.browserTracingIntegration(),
+      Sentry.replayIntegration({
+        maskAllText: true,
+        blockAllMedia: true,
+      }),
+    ],
+    beforeSend(event) {
+      return scrubEvent(event);
+    },
+    beforeSendTransaction(event) {
+      return scrubEvent(event);
+    },
   });
 }
 
-export const onRouterTransitionStart = Sentry.captureRouterTransitionStart;
+/**
+ * Associates the current Sentry scope with a hashed wallet identifier.
+ * The raw wallet address must never be passed here; callers are expected
+ * to provide a one-way hash so no PII leaves the client.
+ */
+export function setUser(hashedWalletId: string | null): void {
+  if (!dsn) {
+    return;
+  }
+
+  if (hashedWalletId) {
+    Sentry.setUser({ id: hashedWalletId });
+  } else {
+    Sentry.setUser(null);
+  }
+}
+
+export const onRouterTransitionStart = Sentry.captureRouterTransitionStart;
\ No newline at end of file
diff --git a/instrumentation.ts b/instrumentation.ts
index 88d64d6d..985e3cd8 100644
--- a/instrumentation.ts
+++ b/instrumentation.ts
@@ -1,22 +1,150 @@
 import * as Sentry from "@sentry/nextjs";
 
+const EMAIL_REGEX = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
+const WALLET_REGEX = /\b0x[a-fA-F0-9]{40}\b/g;
+const COOKIE_REGEX = /(cookie|set-cookie|authorization|bearer)\s*[:=]\s*[^\s,;]+/gi;
+
+function scrubString(value: string): string {
+  return value
+    .replace(EMAIL_REGEX, "[Filtered Email]")
+    .replace(WALLET_REGEX, "[Filtered Wallet]")
+    .replace(COOKIE_REGEX, "$1: [Filtered]");
+}
+
+function scrubValue(value: unknown, depth = 0): unknown {
+  if (depth > 10) return "[Truncated]";
+  if (typeof value === "string") return scrubString(value);
+  if (Array.isArray(value)) return value.map((item) => scrubValue(item, depth + 1));
+  if (value && typeof value === "object") {
+    const result: Record<string, unknown> = {};
+    for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
+      const lowerKey = key.toLowerCase();
+      if (
+        lowerKey.includes("cookie") ||
+        lowerKey.includes("authorization") ||
+        lowerKey.includes("password") ||
+        lowerKey.includes("secret") ||
+        lowerKey.includes("token")
+      ) {
+        result[key] = "[Filtered]";
+      } else {
+        result[key] = scrubValue(val, depth + 1);
+      }
+    }
+    return result;
+  }
+  return value;
+}
+
+function scrubEvent(event: Sentry.ErrorEvent): Sentry.ErrorEvent | null {
+  if (event.request) {
+    if (event.request.headers) {
+      event.request.headers = scrubValue(event.request.headers) as Record<string, string>;
+    }
+    if (event.request.cookies) {
+      event.request.cookies = "[Filtered]";
+    }
+    if (event.request.data) {
+      event.request.data = scrubValue(event.request.data);
+    }
+    if (event.request.query_string) {
+      event.request.query_string = scrubString(String(event.request.query_string));
+    }
+  }
+
+  if (event.user) {
+    event.user = {
+      id: event.user.id,
+    };
+  }
+
+  if (event.message) {
+    event.message = scrubString(event.message);
+  }
+
+  if (event.exception?.values) {
+    event.exception.values = event.exception.values.map((exception) => ({
+      ...exception,
+      value: exception.value ? scrubString(exception.value) : exception.value,
+    }));
+  }
+
+  if (event.breadcrumbs) {
+    event.breadcrumbs = event.breadcrumbs.map((breadcrumb) => ({
+      ...breadcrumb,
+      message: breadcrumb.message ? scrubString(breadcrumb.message) : breadcrumb.message,
+      data: breadcrumb.data ? (scrubValue(breadcrumb.data) as Record<string, unknown>) : breadcrumb.data,
+    }));
+  }
+
+  if (event.extra) {
+    event.extra = scrubValue(event.extra) as Record<string, unknown>;
+  }
+
+  if (event.contexts) {
+    event.contexts = scrubValue(event.contexts) as Record<string, Record<string, unknown>>;
+  }
+
+  return event;
+}
+
+function initSentry(dsn: string) {
+  Sentry.init({
+    dsn,
+    environment: process.env.NEXT_PUBLIC_SENTRY_ENVIRONMENT ?? process.env.NODE_ENV,
+    release: process.env.NEXT_PUBLIC_SENTRY_RELEASE ?? process.env.SENTRY_RELEASE,
+    tracesSampleRate: 0.1,
+    debug: false,
+    sendDefaultPii: false,
+    beforeSend(event) {
+      return scrubEvent(event);
+    },
+    beforeBreadcrumb(breadcrumb) {
+      if (breadcrumb.category === "console") {
+        return null;
+      }
+      if (breadcrumb.message) {
+        breadcrumb.message = scrubString(breadcrumb.message);
+      }
+      if (breadcrumb.data) {
+        breadcrumb.data = scrubValue(breadcrumb.data) as Record<string, unknown>;
+      }
+      return breadcrumb;
+    },
+    initialScope: {
+      tags: {
+        service: "web",
+        org: process.env.NEXT_PUBLIC_SENTRY_ORG ?? "unknown",
+        project: process.env.NEXT_PUBLIC_SENTRY_PROJECT ?? "unknown",
+      },
+    },
+    integrations: (integrations) =>
+      integrations.filter((integration) => integration.name !== "Breadcrumbs" || true),
+    normalizeDepth: 10,
+    maxBreadcrumbs: 50,
+    attachStacktrace: true,
+    ignoreErrors: [
+      "ResizeObserver loop limit exceeded",
+      "ResizeObserver loop completed with undelivered notifications",
+      "Non-Error promise rejection captured",
+    ],
+    denyUrls: [
+      /extensions\//i,
+      /^chrome:\/\//i,
+      /^moz-extension:\/\//i,
+    ],
+  });
+}
+
 export async function register() {
   const dsn = process.env.NEXT_PUBLIC_SENTRY_DSN;
   if (!dsn) return;
 
   if (process.env.NEXT_RUNTIME === "nodejs") {
-    Sentry.init({
-      dsn,
-      tracesSampleRate: 0.1,
-      debug: false,
-    });
+    initSentry(dsn);
   }
 
   if (process.env.NEXT_RUNTIME === "edge") {
-    Sentry.init({
-      dsn,
-      tracesSampleRate: 0.1,
-      debug: false,
-    });
+    initSentry(dsn);
   }
-}
+}
\ No newline at end of file
diff --git a/next.config.js b/next.config.js
index 4957e775..c099a193 100644
--- a/next.config.js
+++ b/next.config.js
@@ -85,6 +85,13 @@ const sentryWebpackPluginOptions = {
   project: process.env.SENTRY_PROJECT,
   authToken: process.env.SENTRY_AUTH_TOKEN,
   silent: true,
+  // Hide source maps from the client bundle; they are uploaded to Sentry instead.
+  hideSourceMaps: true,
+  // Upload source maps for all client files, not just the ones referenced in the bundle.
+  widenClientFileUpload: true,
+  // Route Sentry requests through a same-origin tunnel to avoid ad-blockers.
+  tunnelRoute: '/monitoring',
+  // Only run the Sentry webpack plugins when a DSN is configured.
   disableServerWebpackPlugin: !process.env.NEXT_PUBLIC_SENTRY_DSN,
   disableClientWebpackPlugin: !process.env.NEXT_PUBLIC_SENTRY_DSN,
 };
diff --git a/src/app/admin/feature-flags/page.tsx b/src/app/admin/feature-flags/page.tsx
new file mode 100644
index 00000000..5d6c6f9d
--- /dev/null
+++ b/src/app/admin/feature-flags/page.tsx
@@ -0,0 +1,320 @@
+'use client';
+
+import { useCallback, useEffect, useMemo, useState } from 'react';
+
+type FlagValue = boolean | string | number;
+
+interface FeatureFlag {
+  key: string;
+  description: string;
+  enabled: boolean;
+  rolloutPercentage: number;
+  variants?: string[];
+  defaultValue: FlagValue;
+}
+
+interface FlagOverride {
+  enabled?: boolean;
+  rolloutPercentage?: number;
+}
+
+const ADMIN_FLAG_KEY = 'admin.feature-flags';
+
+const INITIAL_FLAGS: FeatureFlag[] = [
+  {
+    key: 'new-dashboard',
+    description: 'Gradual rollout of the redesigned dashboard experience.',
+    enabled: false,
+    rolloutPercentage: 0,
+    defaultValue: false,
+  },
+  {
+    key: 'checkout-v2',
+    description: 'A/B test for the streamlined checkout flow.',
+    enabled: false,
+    rolloutPercentage: 0,
+    variants: ['control', 'variant-a', 'variant-b'],
+    defaultValue: 'control',
+  },
+  {
+    key: 'search-relevance',
+    description: 'Improved search relevance ranking model.',
+    enabled: true,
+    rolloutPercentage: 25,
+    defaultValue: false,
+  },
+  {
+    key: 'beta-banner',
+    description: 'Show the beta program banner to eligible users.',
+    enabled: false,
+    rolloutPercentage: 10,
+    defaultValue: false,
+  },
+];
+
+function clampPercentage(value: number): number {
+  if (Number.isNaN(value)) return 0;
+  return Math.min(100, Math.max(0, Math.round(value)));
+}
+
+export default function FeatureFlagsAdminPage() {
+  const [flags, setFlags] = useState<FeatureFlag[]>(INITIAL_FLAGS);
+  const [loading, setLoading] = useState(true);
+  const [savingKey, setSavingKey] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [statusMessage, setStatusMessage] = useState<string | null>(null);
+  const [adminEnabled, setAdminEnabled] = useState<boolean | null>(null);
+
+  const loadFlags = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await fetch('/api/admin/feature-flags', {
+        method: 'GET',
+        headers: { Accept: 'application/json' },
+        cache: 'no-store',
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to load flags (${response.status})`);
+      }
+      const data = (await response.json()) as {
+        flags?: FeatureFlag[];
+        adminEnabled?: boolean;
+      };
+      if (Array.isArray(data.flags) && data.flags.length > 0) {
+        setFlags(data.flags);
+      }
+      setAdminEnabled(data.adminEnabled ?? true);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Unable to load feature flags.');
+      // Fall back to local defaults so the UI remains usable.
+      setAdminEnabled(true);
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    void loadFlags();
+  }, [loadFlags]);
+
+  const persistOverride = useCallback(
+    async (key: string, override: FlagOverride) => {
+      setSavingKey(key);
+      setError(null);
+      setStatusMessage(null);
+      try {
+        const response = await fetch('/api/admin/feature-flags', {
+          method: 'PATCH',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ key, override }),
+        });
+        if (!response.ok) {
+          throw new Error(`Failed to save flag "${key}" (${response.status})`);
+        }
+        setStatusMessage(`Saved changes for "${key}".`);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : 'Unable to save flag override.');
+        throw err;
+      } finally {
+        setSavingKey(null);
+      }
+    },
+    []
+  );
+
+  const handleToggle = useCallback(
+    async (flag: FeatureFlag) => {
+      const nextEnabled = !flag.enabled;
+      const previous = flags;
+      setFlags((current) =>
+        current.map((item) =>
+          item.key === flag.key ? { ...item, enabled: nextEnabled } : item
+        )
+      );
+      try {
+        await persistOverride(flag.key, { enabled: nextEnabled });
+      } catch {
+        setFlags(previous);
+      }
+    },
+    [flags, persistOverride]
+  );
+
+  const handleRolloutChange = useCallback(
+    (flag: FeatureFlag, rawValue: string) => {
+      const nextPercentage = clampPercentage(Number(rawValue));
+      setFlags((current) =>
+        current.map((item) =>
+          item.key === flag.key ? { ...item, rolloutPercentage: nextPercentage } : item
+        )
+      );
+    },
+    []
+  );
+
+  const handleRolloutCommit = useCallback(
+    async (flag: FeatureFlag) => {
+      try {
+        await persistOverride(flag.key, { rolloutPercentage: flag.rolloutPercentage });
+      } catch {
+        // Error already surfaced via setError; reload to resync state.
+        void loadFlags();
+      }
+    },
+    [loadFlags, persistOverride]
+  );
+
+  const adminGate = useMemo(() => {
+    if (adminEnabled === null) return 'loading';
+    return adminEnabled ? 'allowed' : 'denied';
+  }, [adminEnabled]);
+
+  if (adminGate === 'loading' || loading) {
+    return (
+      <main className="mx-auto max-w-4xl p-6" aria-busy="true">
+        <h1 className="text-2xl font-semibold">Feature Flags</h1>
+        <p role="status" className="mt-4 text-sm text-gray-600">
+          Loading feature flags…
+        </p>
+      </main>
+    );
+  }
+
+  if (adminGate === 'denied') {
+    return (
+      <main className="mx-auto max-w-4xl p-6">
+        <h1 className="text-2xl font-semibold">Feature Flags</h1>
+        <p role="alert" className="mt-4 rounded border border-red-300 bg-red-50 p-4 text-sm text-red-800">
+          You do not have access to feature flag management. The{' '}
+          <code>{ADMIN_FLAG_KEY}</code> flag is disabled for your account.
+        </p>
+      </main>
+    );
+  }
+
+  return (
+    <main className="mx-auto max-w-4xl p-6">
+      <header className="mb-6">
+        <h1 className="text-2xl font-semibold">Feature Flags</h1>
+        <p className="mt-2 text-sm text-gray-600">
+          Toggle features and control gradual rollout percentages. Changes are saved
+          immediately and tracked in analytics.
+        </p>
+      </header>
+
+      {error && (
+        <div
+          role="alert"
+          className="mb-4 rounded border border-red-300 bg-red-50 p-3 text-sm text-red-800"
+        >
+          {error}
+        </div>
+      )}
+
+      {statusMessage && (
+        <div
+          role="status"
+          aria-live="polite"
+          className="mb-4 rounded border border-green-300 bg-green-50 p-3 text-sm text-green-800"
+        >
+          {statusMessage}
+        </div>
+      )}
+
+      <ul className="space-y-4">
+        {flags.map((flag) => {
+          const isSaving = savingKey === flag.key;
+          const toggleId = `flag-toggle-${flag.key}`;
+          const rolloutId = `flag-rollout-${flag.key}`;
+          const descId = `flag-desc-${flag.key}`;
+
+          return (
+            <li
+              key={flag.key}
+              className="rounded-lg border border-gray-200 p-4 shadow-sm"
+            >
+              <div className="flex flex-col gap-4 sm:flex-row sm:items-start sm:justify-between">
+                <div className="flex-1">
+                  <div className="flex items-center gap-3">
+                    <input
+                      id={toggleId}
+                      type="checkbox"
+                      role="switch"
+                      checked={flag.enabled}
+                      disabled={isSaving}
+                      aria-describedby={descId}
+                      aria-label={`Enable ${flag.key}`}
+                      onChange={() => void handleToggle(flag)}
+                      className="h-5 w-5 cursor-pointer"
+                    />
+                    <label
+                      htmlFor={toggleId}
+                      className="font-mono text-sm font-medium"
+                    >
+                      {flag.key}
+                    </label>
+                    <span
+                      className={`rounded-full px-2 py-0.5 text-xs font-medium ${
+                        flag.enabled
+                          ? 'bg-green-100 text-green-800'
+                          : 'bg-gray-100 text-gray-700'
+                      }`}
+                    >
+                      {flag.enabled ? 'Enabled' : 'Disabled'}
+                    </span>
+                  </div>
+                  <p id={descId} className="mt-2 text-sm text-gray-600">
+                    {flag.description}
+                  </p>
+                  {flag.variants && flag.variants.length > 0 && (
+                    <p className="mt-1 text-xs text-gray-500">
+                      Variants: {flag.variants.join(', ')}
+                    </p>
+                  )}
+                </div>
+
+                <div className="w-full sm:w-64">
+                  <label
+                    htmlFor={rolloutId}
+                    className="block text-sm font-medium text-gray-700"
+                  >
+                    Rollout: {flag.rolloutPercentage}%
+                  </label>
+                  <input
+                    id={rolloutId}
+                    type="range"
+                    min={0}
+                    max={100}
+                    step={5}
+                    value={flag.rolloutPercentage}
+                    disabled={isSaving}
+                    aria-valuemin={0}
+                    aria-valuemax={100}
+                    aria-valuenow={flag.rolloutPercentage}
+                    aria-label={`Rollout percentage for ${flag.key}`}
+                    onChange={(event) => handleRolloutChange(flag, event.target.value)}
+                    onMouseUp={() => void handleRolloutCommit(flag)}
+                    onTouchEnd={() => void handleRolloutCommit(flag)}
+                    onKeyUp={() => void handleRolloutCommit(flag)}
+                    className="mt-1 w-full cursor-pointer"
+                  />
+                  <div className="mt-1 flex items-center justify-between text-xs text-gray-500">
+                    <span>0%</span>
+                    <span>100%</span>
+                  </div>
+                </div>
+              </div>
+
+              {isSaving && (
+                <p role="status" className="mt-2 text-xs text-gray-500">
+                  Saving…
+                </p>
+              )}
+            </li>
+          );
+        })}
+      </ul>
+    </main>
+  );
+}
\ No newline at end of file
diff --git a/src/app/api/feature-flags/route.ts b/src/app/api/feature-flags/route.ts
new file mode 100644
index 00000000..af731c96
--- /dev/null
+++ b/src/app/api/feature-flags/route.ts
@@ -0,0 +1,215 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { apiClient } from '@/lib/apiClient';
+
+export const dynamic = 'force-dynamic';
+
+interface FeatureFlag {
+  key: string;
+  enabled: boolean;
+  rolloutPercentage: number;
+  variant?: string;
+  description?: string;
+}
+
+interface FlagOverride {
+  key: string;
+  enabled?: boolean;
+  variant?: string;
+  userId?: string;
+  rolloutPercentage?: number;
+}
+
+interface EvaluationContext {
+  userId?: string;
+  sessionId?: string;
+  attributes?: Record<string, unknown>;
+}
+
+const DEFAULT_FLAGS: FeatureFlag[] = [
+  {
+    key: 'new-dashboard',
+    enabled: true,
+    rolloutPercentage: 25,
+    variant: 'control',
+    description: 'Gradual rollout of the redesigned dashboard',
+  },
+  {
+    key: 'ab-test-checkout',
+    enabled: true,
+    rolloutPercentage: 50,
+    variant: 'control',
+    description: 'A/B test for the new checkout flow',
+  },
+  {
+    key: 'analytics-v2',
+    enabled: false,
+    rolloutPercentage: 0,
+    variant: 'control',
+    description: 'Next generation analytics pipeline',
+  },
+];
+
+const overridesStore = new Map<string, FlagOverride>();
+
+function hashString(value: string): number {
+  let hash = 0;
+  for (let i = 0; i < value.length; i += 1) {
+    hash = (hash << 5) - hash + value.charCodeAt(i);
+    hash |= 0;
+  }
+  return Math.abs(hash);
+}
+
+function isInRollout(flagKey: string, context: EvaluationContext, percentage: number): boolean {
+  if (percentage <= 0) return false;
+  if (percentage >= 100) return true;
+  const bucketKey = context.userId || context.sessionId || 'anonymous';
+  const bucket = hashString(`${flagKey}:${bucketKey}`) % 100;
+  return bucket < percentage;
+}
+
+function evaluateFlag(flag: FeatureFlag, context: EvaluationContext): FeatureFlag {
+  const override = overridesStore.get(flag.key);
+  const enabled = override?.enabled ?? flag.enabled;
+  const rolloutPercentage = override?.rolloutPercentage ?? flag.rolloutPercentage;
+  const variant = override?.variant ?? flag.variant;
+
+  if (!enabled) {
+    return { ...flag, enabled: false, variant: 'off' };
+  }
+
+  const inRollout = isInRollout(flag.key, context, rolloutPercentage);
+  return {
+    ...flag,
+    enabled: inRollout,
+    rolloutPercentage,
+    variant: inRollout ? variant : 'off',
+  };
+}
+
+function isAdmin(request: NextRequest): boolean {
+  const role = request.headers.get('x-user-role');
+  return role === 'admin';
+}
+
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  try {
+    const { searchParams } = new URL(request.url);
+    const userId = searchParams.get('userId') ?? request.headers.get('x-user-id') ?? undefined;
+    const sessionId = searchParams.get('sessionId') ?? undefined;
+
+    const context: EvaluationContext = { userId, sessionId };
+
+    const evaluated = DEFAULT_FLAGS.map((flag) => evaluateFlag(flag, context));
+
+    return NextResponse.json(
+      {
+        flags: evaluated,
+        context: { userId, sessionId },
+        evaluatedAt: new Date().toISOString(),
+      },
+      { status: 200 },
+    );
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to evaluate feature flags', details: (error as Error).message },
+      { status: 500 },
+    );
+  }
+}
+
+export async function POST(request: NextRequest): Promise<NextResponse> {
+  if (!isAdmin(request)) {
+    return NextResponse.json({ error: 'Forbidden: admin access required' }, { status: 403 });
+  }
+
+  try {
+    const body = (await request.json()) as FlagOverride;
+
+    if (!body || typeof body.key !== 'string' || body.key.length === 0) {
+      return NextResponse.json({ error: 'Invalid payload: "key" is required' }, { status: 400 });
+    }
+
+    if (!DEFAULT_FLAGS.some((flag) => flag.key === body.key)) {
+      return NextResponse.json({ error: `Unknown feature flag: ${body.key}` }, { status: 404 });
+    }
+
+    if (
+      body.rolloutPercentage !== undefined &&
+      (typeof body.rolloutPercentage !== 'number' ||
+        body.rolloutPercentage < 0 ||
+        body.rolloutPercentage > 100)
+    ) {
+      return NextResponse.json(
+        { error: 'Invalid payload: "rolloutPercentage" must be between 0 and 100' },
+        { status: 400 },
+      );
+    }
+
+    const override: FlagOverride = {
+      key: body.key,
+      enabled: body.enabled,
+      variant: body.variant,
+      userId: body.userId,
+      rolloutPercentage: body.rolloutPercentage,
+    };
+
+    const response = await apiClient.post('/api/feature-flags/overrides', override);
+
+    if (!response.ok) {
+      return NextResponse.json(
+        { error: 'Failed to persist feature flag override' },
+        { status: response.status },
+      );
+    }
+
+    overridesStore.set(body.key, override);
+
+    return NextResponse.json(
+      {
+        success: true,
+        override,
+        updatedAt: new Date().toISOString(),
+      },
+      { status: 200 },
+    );
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to update feature flag override', details: (error as Error).message },
+      { status: 500 },
+    );
+  }
+}
+
+export async function DELETE(request: NextRequest): Promise<NextResponse> {
+  if (!isAdmin(request)) {
+    return NextResponse.json({ error: 'Forbidden: admin access required' }, { status: 403 });
+  }
+
+  try {
+    const { searchParams } = new URL(request.url);
+    const key = searchParams.get('key');
+
+    if (!key) {
+      return NextResponse.json({ error: 'Query parameter "key" is required' }, { status: 400 });
+    }
+
+    const response = await apiClient.delete(`/api/feature-flags/overrides/${encodeURIComponent(key)}`);
+
+    if (!response.ok) {
+      return NextResponse.json(
+        { error: 'Failed to remove feature flag override' },
+        { status: response.status },
+      );
+    }
+
+    overridesStore.delete(key);
+
+    return NextResponse.json({ success: true, key }, { status: 200 });
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to remove feature flag override', details: (error as Error).message },
+      { status: 500 },
+    );
+  }
+}
\ No newline at end of file
diff --git a/src/app/error.tsx b/src/app/error.tsx
index 00de11b1..69b2f29c 100644
--- a/src/app/error.tsx
+++ b/src/app/error.tsx
@@ -1,7 +1,9 @@
 "use client";
 
 import Link from "next/link";
+import { usePathname } from "next/navigation";
 import { useEffect } from "react";
+import * as Sentry from "@sentry/nextjs";
 
 interface Props {
   error: Error & { digest?: string };
@@ -9,13 +11,24 @@ interface Props {
 }
 
 export default function GlobalError({ error, reset }: Props) {
+  const pathname = usePathname();
+
   useEffect(() => {
     console.error("[GlobalError]", {
       message: error.message,
       digest: error.digest,
       stack: error.stack,
     });
-  }, [error]);
+
+    Sentry.withScope((scope) => {
+      scope.setTag("error_boundary", "app/error");
+      if (error.digest) {
+        scope.setTag("digest", error.digest);
+      }
+      scope.setContext("route", { pathname });
+      Sentry.captureException(error);
+    });
+  }, [error, pathname]);
 
   return (
     <main className="min-h-screen bg-gray-950 text-gray-100 flex items-center justify-center px-4">
diff --git a/src/app/layout.tsx b/src/app/layout.tsx
index 4714ebf9..4477a5d4 100644
--- a/src/app/layout.tsx
+++ b/src/app/layout.tsx
@@ -143,7 +143,15 @@ export default function RootLayout({
                                 <p className="text-xs text-gray-500">
                                   © {new Date().getFullYear()} StellarSplit
                                 </p>
-                                <LanguageSwitcher />
+                                <div className="flex flex-wrap items-center gap-4">
+                                  <a
+                                    href="/docs/user-guide"
+                                    className="text-xs text-gray-500 hover:text-gray-700 dark:hover:text-gray-300 underline-offset-2 hover:underline focus:outline-none focus-visible:ring-2 focus-visible:ring-blue-500 rounded"
+                                  >
+                                    Help &amp; User Guide
+                                  </a>
+                                  <LanguageSwitcher />
+                                </div>
                               </div>
                             </footer>
                             <CommandPalette />
diff --git a/src/components/Breadcrumb.tsx b/src/components/Breadcrumb.tsx
index fe4dfc85..178fd0a3 100644
--- a/src/components/Breadcrumb.tsx
+++ b/src/components/Breadcrumb.tsx
@@ -7,7 +7,47 @@ export interface BreadcrumbItem {
 }
 
 interface Props {
-  items: BreadcrumbItem[];
+  items?: BreadcrumbItem[];
+}
+
+const HOME_ITEM: BreadcrumbItem = { label: "Home", href: "/" };
+
+/**
+ * Convert a URL segment into a human-readable label.
+ * e.g. "getting-started" -> "Getting Started"
+ */
+export function formatSegmentLabel(segment: string): string {
+  return segment
+    .split("-")
+    .filter(Boolean)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(" ");
+}
+
+/**
+ * Build a breadcrumb trail from a pathname.
+ * Pages can pass `labels` to override the generated label for a given href.
+ */
+export function buildBreadcrumbTrail(
+  pathname: string,
+  labels: Record<string, string> = {}
+): BreadcrumbItem[] {
+  const segments = pathname.split("/").filter(Boolean);
+  if (segments.length === 0) return [];
+
+  const trail: BreadcrumbItem[] = [HOME_ITEM];
+  let href = "";
+
+  segments.forEach((segment, index) => {
+    href += `/${segment}`;
+    const isLast = index === segments.length - 1;
+    trail.push({
+      label: labels[href] ?? formatSegmentLabel(segment),
+      href: isLast ? undefined : href,
+    });
+  });
+
+  return trail;
 }
 
 export default function Breadcrumb({ items }: Props) {
@@ -16,74 +56,41 @@ export default function Breadcrumb({ items }: Props) {
 
   if (isHome) return null;
 
-  // Mobile: show only last 2 items
-  const displayItems = items.length > 2 ? items.slice(-2) : items;
-  const showEllipsis = items.length > 2;
+  const trail = items && items.length > 0 ? items : buildBreadcrumbTrail(pathname);
+
+  // Avoid duplicate Home entries (e.g. when items already start with Home)
+  const normalized = trail.filter(
+    (item, i) => !(i > 0 && item.href === "/" && trail[0]?.href === "/")
+  );
+
+  if (normalized.length === 0) return null;
 
   return (
     <nav
-      className="flex items-center gap-1 text-sm text-gray-400 px-4 sm:px-6 py-2 border-b border-gray-800"
+      className="flex items-center gap-1 text-sm text-gray-400 px-4 sm:px-6 py-2 border-b border-gray-800 overflow-x-auto"
       aria-label="Breadcrumb"
     >
       <ol className="flex items-center gap-1">
-        {showEllipsis && (
-          <>
-            <li>
-              <Link
-                href="/"
-                className="hover:text-gray-200 transition-colors"
-              >
-                Home
-              </Link>
-            </li>
-            <li aria-hidden="true" className="text-gray-600">
-              …
-            </li>
-          </>
-        )}
-        {displayItems.map((item, i) => {
-          const isLast = i === displayItems.length - 1;
+        {normalized.map((item, i) => {
+          const isLast = i === normalized.length - 1;
           return (
-            <li key={item.label} className="flex items-center gap-1">
-              {!isLast && i > 0 && (
+            <li key={`${item.label}-${i}`} className="flex items-center gap-1">
+              {i > 0 && (
                 <span aria-hidden="true" className="text-gray-600">
                   /
                 </span>
               )}
               {isLast ? (
-                <span className="text-gray-300 font-medium" aria-current="page">{item.label}</span>
+                <span className="text-gray-300 font-medium" aria-current="page">
+                  {item.label}
+                </span>
               ) : (
-                <>
-                  {i === 0 && !showEllipsis && (
-                    <Link
-                      href="/"
-                      className="hover:text-gray-200 transition-colors"
-                    >
-                      Home
-                    </Link>
-                  )}
-                  {i > 0 && (
-                    <>
-                      <span aria-hidden="true" className="text-gray-600">
-                        /
-                      </span>
-                      <Link
-                        href={item.href || "#"}
-                        className="hover:text-gray-200 transition-colors"
-                      >
-                        {item.label}
-                      </Link>
-                    </>
-                  )}
-                  {i === 0 && !showEllipsis && (
-                    <>
-                      <span aria-hidden="true" className="text-gray-600">
-                        /
-                      </span>
-                      <span className="text-gray-300">{item.label}</span>
-                    </>
-                  )}
-                </>
+                <Link
+                  href={item.href || "/"}
+                  className="hover:text-gray-200 transition-colors"
+                >
+                  {item.label}
+                </Link>
               )}
             </li>
           );
diff --git a/src/components/ErrorBoundary.tsx b/src/components/ErrorBoundary.tsx
index 31fac810..90e434c0 100644
--- a/src/components/ErrorBoundary.tsx
+++ b/src/components/ErrorBoundary.tsx
@@ -4,6 +4,7 @@ import { Component, type ReactNode } from "react";
 import Link from "next/link";
 import WalletConnect from "@/components/WalletConnect";
 import { classifyError } from "@/lib/errors";
+import { getWalletAddress, hashWalletAddress } from "@/lib/errorTracking";
 
 interface Props {
   children: ReactNode;
@@ -29,8 +30,27 @@ export default class ErrorBoundary extends Component<Props, State> {
       // Sentry is only initialised when NEXT_PUBLIC_SENTRY_DSN is set.
       // Dynamic import keeps it out of the production bundle when unconfigured.
       const Sentry = await import("@sentry/nextjs");
-      const eventId = Sentry.captureException(error);
-      this.setState({ sentryEventId: eventId });
+      const { kind } = classifyError(error);
+
+      Sentry.withScope((scope) => {
+        // Stable grouping: fingerprint by error kind so identical failure
+        // classes are grouped together regardless of message/stack variance.
+        scope.setFingerprint(["error-boundary", kind]);
+        scope.setTag("error.kind", kind);
+        scope.setTag("error.boundary", "root");
+
+        if (typeof window !== "undefined") {
+          scope.setTag("route.pathname", window.location.pathname);
+        }
+
+        const walletAddress = getWalletAddress();
+        if (walletAddress) {
+          scope.setTag("wallet.address_hash", hashWalletAddress(walletAddress));
+        }
+
+        const eventId = Sentry.captureException(error);
+        this.setState({ sentryEventId: eventId });
+      });
     } catch {
       // Sentry unavailable — continue without it
     }
diff --git a/src/components/HelpTooltip.tsx b/src/components/HelpTooltip.tsx
new file mode 100644
index 00000000..e03d652a
--- /dev/null
+++ b/src/components/HelpTooltip.tsx
@@ -0,0 +1,288 @@
+import React, { useCallback, useEffect, useId, useRef, useState } from 'react';
+import { getHelpEntry } from '../lib/helpContent';
+import { trackHelpEvent } from '../lib/helpAnalytics';
+
+export interface HelpTooltipProps {
+  /** Key into the help content registry. */
+  helpKey: string;
+  /** Optional override for the accessible label of the trigger button. */
+  label?: string;
+  /** Optional placement of the tooltip relative to the trigger. */
+  placement?: 'top' | 'bottom' | 'left' | 'right';
+  /** Optional additional class names for the wrapper. */
+  className?: string;
+}
+
+const PLACEMENT_STYLES: Record<NonNullable<HelpTooltipProps['placement']>, React.CSSProperties> = {
+  top: { bottom: '100%', left: '50%', transform: 'translate(-50%, -8px)' },
+  bottom: { top: '100%', left: '50%', transform: 'translate(-50%, 8px)' },
+  left: { right: '100%', top: '50%', transform: 'translate(-8px, -50%)' },
+  right: { left: '100%', top: '50%', transform: 'translate(8px, -50%)' },
+};
+
+/**
+ * A focusable help icon button that reveals contextual help text.
+ *
+ * Accessibility:
+ * - The trigger is a real <button> so it is keyboard focusable and activatable.
+ * - The tooltip element is referenced via aria-describedby so screen readers
+ *   announce the help text when the trigger receives focus.
+ * - Escape dismisses the tooltip and returns focus to the trigger.
+ * - The tooltip uses role="tooltip" and is hidden from the accessibility tree
+ *   when not visible.
+ */
+export const HelpTooltip: React.FC<HelpTooltipProps> = ({
+  helpKey,
+  label,
+  placement = 'top',
+  className,
+}) => {
+  const entry = getHelpEntry(helpKey);
+  const tooltipId = useId();
+  const triggerRef = useRef<HTMLButtonElement | null>(null);
+  const [open, setOpen] = useState(false);
+
+  const show = useCallback(() => {
+    setOpen(true);
+    trackHelpEvent('help_opened', { helpKey });
+  }, [helpKey]);
+
+  const hide = useCallback(() => {
+    setOpen(false);
+  }, []);
+
+  const handleClick = useCallback(() => {
+    if (open) {
+      hide();
+    } else {
+      show();
+    }
+  }, [open, show, hide]);
+
+  const handleKeyDown = useCallback(
+    (event: React.KeyboardEvent<HTMLButtonElement>) => {
+      if (event.key === 'Escape' && open) {
+        event.stopPropagation();
+        hide();
+        triggerRef.current?.focus();
+      }
+    },
+    [open, hide],
+  );
+
+  // Dismiss on outside click / focus loss.
+  useEffect(() => {
+    if (!open) {
+      return;
+    }
+
+    const handlePointerDown = (event: MouseEvent | TouchEvent) => {
+      const target = event.target as Node | null;
+      if (triggerRef.current && target && !triggerRef.current.contains(target)) {
+        hide();
+      }
+    };
+
+    document.addEventListener('mousedown', handlePointerDown);
+    document.addEventListener('touchstart', handlePointerDown);
+    return () => {
+      document.removeEventListener('mousedown', handlePointerDown);
+      document.removeEventListener('touchstart', handlePointerDown);
+    };
+  }, [open, hide]);
+
+  if (!entry) {
+    // Fail safe: render nothing if the help key is unknown.
+    return null;
+  }
+
+  const accessibleLabel = label ?? `Help: ${entry.title}`;
+
+  return (
+    <span
+      className={['help-tooltip', className].filter(Boolean).join(' ')}
+      style={{ position: 'relative', display: 'inline-flex', alignItems: 'center' }}
+    >
+      <button
+        ref={triggerRef}
+        type="button"
+        className="help-tooltip__trigger"
+        aria-label={accessibleLabel}
+        aria-describedby={open ? tooltipId : undefined}
+        aria-expanded={open}
+        aria-haspopup="true"
+        onClick={handleClick}
+        onKeyDown={handleKeyDown}
+        onFocus={show}
+        onMouseEnter={show}
+        onMouseLeave={hide}
+        style={{
+          display: 'inline-flex',
+          alignItems: 'center',
+          justifyContent: 'center',
+          width: '1.25rem',
+          height: '1.25rem',
+          padding: 0,
+          border: '1px solid currentColor',
+          borderRadius: '50%',
+          background: 'transparent',
+          color: 'inherit',
+          cursor: 'pointer',
+          fontSize: '0.75rem',
+          lineHeight: 1,
+        }}
+      >
+        <span aria-hidden="true">?</span>
+      </button>
+      {open && (
+        <span
+          id={tooltipId}
+          role="tooltip"
+          className="help-tooltip__content"
+          style={{
+            position: 'absolute',
+            zIndex: 1000,
+            minWidth: '12rem',
+            maxWidth: '20rem',
+            padding: '0.5rem 0.75rem',
+            borderRadius: '0.375rem',
+            background: '#1f2937',
+            color: '#f9fafb',
+            fontSize: '0.8125rem',
+            lineHeight: 1.4,
+            boxShadow: '0 4px 12px rgba(0, 0, 0, 0.2)',
+            ...PLACEMENT_STYLES[placement],
+          }}
+        >
+          <strong style={{ display: 'block', marginBottom: '0.25rem' }}>{entry.title}</strong>
+          <span>{entry.body}</span>
+        </span>
+      )}
+    </span>
+  );
+};
+
+export default HelpTooltip;
+```
+
+```ts
+export interface HelpEntry {
+  /** Unique identifier used to look up the entry. */
+  id: string;
+  /** Short title shown in the tooltip header. */
+  title: string;
+  /** Body text providing contextual help. */
+  body: string;
+  /** Optional related documentation URL. */
+  learnMoreUrl?: string;
+}
+
+/**
+ * Registry of contextual help entries keyed by id.
+ *
+ * Keys are stable identifiers referenced by HelpTooltip and contextual help
+ * components throughout the app. Add new entries here so they can be reused.
+ */
+export const helpContent: Record<string, HelpEntry> = {
+  'dashboard.overview': {
+    id: 'dashboard.overview',
+    title: 'Dashboard overview',
+    body: 'This dashboard summarizes your key metrics. Use the filters above to narrow the data shown.',
+  },
+  'dashboard.metrics': {
+    id: 'dashboard.metrics',
+    title: 'Metrics',
+    body: 'Metrics are refreshed every few minutes. Hover over a chart to see detailed values for a point in time.',
+  },
+  'navigation.breadcrumbs': {
+    id: 'navigation.breadcrumbs',
+    title: 'Breadcrumbs',
+    body: 'Breadcrumbs show where you are in the app and let you jump back to any parent page.',
+  },
+  'search.input': {
+    id: 'search.input',
+    title: 'Search',
+    body: 'Search across records by name, id, or tag. Press Enter to run the search or Escape to clear it.',
+  },
+  'settings.notifications': {
+    id: 'settings.notifications',
+    title: 'Notifications',
+    body: 'Choose which events trigger notifications and how you would like to receive them.',
+  },
+  'settings.privacy': {
+    id: 'settings.privacy',
+    title: 'Privacy',
+    body: 'Control how your data is stored and shared. Changes take effect immediately.',
+  },
+  'forms.required': {
+    id: 'forms.required',
+    title: 'Required fields',
+    body: 'Fields marked with an asterisk are required and must be completed before saving.',
+  },
+  'reports.export': {
+    id: 'reports.export',
+    title: 'Export reports',
+    body: 'Export the current report as CSV or PDF. Large reports may take a moment to generate.',
+  },
+};
+
+/**
+ * Look up a help entry by id.
+ * Returns undefined when the key is unknown so callers can fail gracefully.
+ */
+export function getHelpEntry(id: string): HelpEntry | undefined {
+  return helpContent[id];
+}
+
+/**
+ * List all registered help entries.
+ */
+export function listHelpEntries(): HelpEntry[] {
+  return Object.values(helpContent);
+}
+
+export default helpContent;
+```
+
+```ts
+/**
+ * Lightweight help analytics helper.
+ *
+ * Emits help-related analytics events. The transport is intentionally pluggable
+ * so the app can wire in its analytics provider (Segment, GA, custom, etc.)
+ * without changing call sites.
+ */
+
+export type HelpEventName = 'help_opened' | 'help_closed' | 'help_link_clicked';
+
+export interface HelpEventPayload {
+  helpKey: string;
+  [key: string]: unknown;
+}
+
+export type HelpEventTransport = (eventName: HelpEventName, payload: HelpEventPayload) => void;
+
+let transport: HelpEventTransport | null = null;
+
+/**
+ * Register the analytics transport used to send help events.
+ * Pass null to disable tracking.
+ */
+export function setHelpAnalyticsTransport(next: HelpEventTransport | null): void {
+  transport = next;
+}
+
+/**
+ * Track a help analytics event. Safe to call even when no transport is
+ * registered (events are silently dropped).
+ */
+export function trackHelpEvent(eventName: HelpEventName, payload: HelpEventPayload): void {
+  if (!transport) {
+    return;
+  }
+  try {
+    transport(eventName, payload);
+  } catch {
+    // Analytics must never break the UI.
+  }
+}
\ No newline at end of file
diff --git a/src/components/Navbar.tsx b/src/components/Navbar.tsx
index 387d5623..9da87d2c 100644
--- a/src/components/Navbar.tsx
+++ b/src/components/Navbar.tsx
@@ -10,6 +10,8 @@ import HeaderShortcutsButton from "@/components/HeaderShortcutsButton";
 import NetworkStatus from "@/components/NetworkStatus";
 import GlobalSearch from "@/components/GlobalSearch";
 import MobileSidebar from "@/components/layout/MobileSidebar";
+import Breadcrumb from "@/components/Breadcrumb";
+import HelpTooltip from "@/components/HelpTooltip";
 
 const NAV_LINKS = [
   { href: "/dashboard",            label: "Dashboard" },
@@ -111,6 +113,11 @@ export default function Navbar() {
               <SimulationModeToggle />
               <NotificationCenter />
               <HeaderShortcutsButton />
+              <HelpTooltip
+                content="Open the user guide to learn about invoices, subscriptions, groups, and more."
+                href="/help"
+                label="Help and user guide"
+              />
             </div>
             <ThemeToggle />
 
@@ -141,6 +148,15 @@ export default function Navbar() {
         </div>
       </header>
 
+      {/* Contextual breadcrumb trail — hidden on the home route */}
+      {pathname !== "/" && (
+        <div className="border-b border-white/[0.06] bg-surface-900/80">
+          <div className="mx-auto max-w-7xl px-4 sm:px-6 py-2">
+            <Breadcrumb />
+          </div>
+        </div>
+      )}
+
       {/* Slide-in sidebar for below lg */}
       <MobileSidebar
         isOpen={sidebarOpen}
diff --git a/src/components/OnboardingFlow.tsx b/src/components/OnboardingFlow.tsx
index cb6ecde8..38dbca57 100644
--- a/src/components/OnboardingFlow.tsx
+++ b/src/components/OnboardingFlow.tsx
@@ -319,6 +319,15 @@ export default function OnboardingFlow() {
                 <li className="flex items-center gap-2"><span className="text-brand-400">✦</span> Track payments in real time with on-chain proof</li>
                 <li className="flex items-center gap-2"><span className="text-brand-400">✦</span> Export receipts and share QR codes</li>
               </ul>
+              <a
+                href="/docs/user-guide/getting-started.md"
+                target="_blank"
+                rel="noopener noreferrer"
+                aria-label="Read the getting started guide (opens in a new tab)"
+                className="mt-3 inline-flex items-center gap-1 text-xs font-semibold text-brand-300 hover:text-brand-200 underline"
+              >
+                Read the getting started guide →
+              </a>
             </div>
           )}
 
@@ -364,17 +373,36 @@ export default function OnboardingFlow() {
           )}
 
           {step === 5 && (
-            <div className="mt-2">
+            <div className="mt-2 flex flex-col gap-3">
               <OnboardingChecklist
                 completed={checklistDone}
                 onToggle={handleToggleChecklist}
               />
+              <a
+                href="/docs/user-guide/getting-started.md"
+                target="_blank"
+                rel="noopener noreferrer"
+                aria-label="View the full user guide (opens in a new tab)"
+                className="self-center text-xs font-semibold text-brand-400 hover:text-brand-300 underline"
+              >
+                View full guide →
+              </a>
             </div>
           )}
         </div>
 
         {/* Footer actions */}
-        <div className="px-6 pb-6 flex gap-3">
+        <div className="px-6 pb-6 flex flex-col gap-3">
+          <a
+            href="/docs/user-guide/getting-started.md"
+            target="_blank"
+            rel="noopener noreferrer"
+            aria-label="View full user guide (opens in a new tab)"
+            className="self-center text-xs text-slate-400 hover:text-slate-300 underline transition-colors"
+          >
+            View full guide →
+          </a>
+          <div className="flex gap-3">
           {step > 1 && (
             <button
               onClick={handleBack}
@@ -389,6 +417,7 @@ export default function OnboardingFlow() {
           >
             {step === TOTAL_STEPS ? "Get started" : "Next"}
           </button>
+          </div>
         </div>
       </div>
     </div>
diff --git a/src/contexts/FeatureFlagContext.tsx b/src/contexts/FeatureFlagContext.tsx
new file mode 100644
index 00000000..a36355e2
--- /dev/null
+++ b/src/contexts/FeatureFlagContext.tsx
@@ -0,0 +1,333 @@
+'use client';
+
+import React, {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
+
+/**
+ * Feature flag context for gradual rollout, A/B testing and analytics.
+ *
+ * Flags are loaded from a remote source (with a local fallback) and evaluated
+ * client-side. Exposure events are emitted once per flag per session so that
+ * analytics can attribute behaviour to the flag variant a user saw.
+ */
+
+export type FeatureFlagValue = boolean | string | number;
+
+export interface FeatureFlagDefinition {
+  key: string;
+  /** Default value used when no remote value is available. */
+  defaultValue: FeatureFlagValue;
+  /** Optional percentage (0-100) of users for whom the flag is enabled. */
+  rolloutPercentage?: number;
+  /** Optional variants for A/B testing. */
+  variants?: Record<string, FeatureFlagValue>;
+  /** Optional description for documentation / UI. */
+  description?: string;
+}
+
+export type FeatureFlagMap = Record<string, FeatureFlagValue>;
+
+export interface FeatureFlagContextValue {
+  flags: FeatureFlagMap;
+  isLoading: boolean;
+  error: Error | null;
+  /** Re-fetch flags from the remote source. */
+  refresh: () => Promise<void>;
+  /** Override a flag locally (used by the flag control UI). */
+  setFlag: (key: string, value: FeatureFlagValue) => void;
+  /** Evaluate a single flag. */
+  getFlag: (key: string, fallback?: FeatureFlagValue) => FeatureFlagValue;
+}
+
+const FeatureFlagContext = createContext<FeatureFlagContextValue | null>(null);
+
+const SESSION_STORAGE_KEY = 'ff:session-id';
+const EXPOSURE_STORAGE_KEY = 'ff:exposures';
+const OVERRIDES_STORAGE_KEY = 'ff:overrides';
+
+/** Default flag definitions. Keep in sync with config/feature-flags.json. */
+export const DEFAULT_FLAGS: FeatureFlagDefinition[] = [
+  {
+    key: 'new-dashboard',
+    defaultValue: false,
+    rolloutPercentage: 10,
+    description: 'Gradual rollout of the redesigned dashboard.',
+  },
+  {
+    key: 'checkout-experiment',
+    defaultValue: 'control',
+    variants: { control: 'control', variant_a: 'variant_a', variant_b: 'variant_b' },
+    description: 'A/B test for the checkout flow.',
+  },
+];
+
+function getSessionId(): string {
+  if (typeof window === 'undefined') return 'server';
+  try {
+    let id = window.sessionStorage.getItem(SESSION_STORAGE_KEY);
+    if (!id) {
+      id =
+        typeof crypto !== 'undefined' && 'randomUUID' in crypto
+          ? crypto.randomUUID()
+          : `sess-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+      window.sessionStorage.setItem(SESSION_STORAGE_KEY, id);
+    }
+    return id;
+  } catch {
+    return 'anonymous';
+  }
+}
+
+/** Deterministic hash so a user consistently falls in the same bucket. */
+function hashToBucket(input: string): number {
+  let hash = 0;
+  for (let i = 0; i < input.length; i += 1) {
+    hash = (hash << 5) - hash + input.charCodeAt(i);
+    hash |= 0;
+  }
+  return Math.abs(hash) % 100;
+}
+
+function evaluateFlag(
+  definition: FeatureFlagDefinition,
+  remoteValue: FeatureFlagValue | undefined,
+  sessionId: string,
+): FeatureFlagValue {
+  if (remoteValue !== undefined) return remoteValue;
+
+  if (definition.variants) {
+    const variantKeys = Object.keys(definition.variants);
+    if (variantKeys.length > 0) {
+      const bucket = hashToBucket(`${sessionId}:${definition.key}`);
+      const index = bucket % variantKeys.length;
+      return definition.variants[variantKeys[index]];
+    }
+  }
+
+  if (typeof definition.rolloutPercentage === 'number') {
+    const bucket = hashToBucket(`${sessionId}:${definition.key}`);
+    return bucket < definition.rolloutPercentage;
+  }
+
+  return definition.defaultValue;
+}
+
+function readOverrides(): FeatureFlagMap {
+  if (typeof window === 'undefined') return {};
+  try {
+    const raw = window.localStorage.getItem(OVERRIDES_STORAGE_KEY);
+    return raw ? (JSON.parse(raw) as FeatureFlagMap) : {};
+  } catch {
+    return {};
+  }
+}
+
+function writeOverrides(overrides: FeatureFlagMap): void {
+  if (typeof window === 'undefined') return;
+  try {
+    window.localStorage.setItem(OVERRIDES_STORAGE_KEY, JSON.stringify(overrides));
+  } catch {
+    /* ignore storage errors */
+  }
+}
+
+function hasTrackedExposure(key: string): boolean {
+  if (typeof window === 'undefined') return true;
+  try {
+    const raw = window.sessionStorage.getItem(EXPOSURE_STORAGE_KEY);
+    const tracked: string[] = raw ? JSON.parse(raw) : [];
+    if (tracked.includes(key)) return true;
+    tracked.push(key);
+    window.sessionStorage.setItem(EXPOSURE_STORAGE_KEY, JSON.stringify(tracked));
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Emit an exposure event for analytics. Integrate with your analytics provider
+ * (Segment, Amplitude, PostHog, etc.) inside this function.
+ */
+export function trackFeatureFlagExposure(
+  key: string,
+  value: FeatureFlagValue,
+): void {
+  if (typeof window === 'undefined') return;
+  const payload = {
+    event: 'feature_flag_exposure',
+    flagKey: key,
+    flagValue: value,
+    sessionId: getSessionId(),
+    timestamp: new Date().toISOString(),
+  };
+
+  // Dispatch a DOM event so any analytics listener can pick it up.
+  try {
+    window.dispatchEvent(new CustomEvent('feature-flag-exposure', { detail: payload }));
+  } catch {
+    /* ignore */
+  }
+
+  // Optional: forward to a global analytics hook if present.
+  const analytics = (window as unknown as { analytics?: { track?: (e: string, p: unknown) => void } })
+    .analytics;
+  if (analytics && typeof analytics.track === 'function') {
+    analytics.track(payload.event, payload);
+  }
+}
+
+async function fetchRemoteFlags(): Promise<FeatureFlagMap> {
+  try {
+    const response = await fetch('/api/feature-flags', {
+      method: 'GET',
+      headers: { Accept: 'application/json' },
+      cache: 'no-store',
+    });
+    if (!response.ok) return {};
+    const data = (await response.json()) as { flags?: FeatureFlagMap } | FeatureFlagMap;
+    if (data && typeof data === 'object' && 'flags' in data && data.flags) {
+      return data.flags;
+    }
+    return (data as FeatureFlagMap) ?? {};
+  } catch {
+    return {};
+  }
+}
+
+export interface FeatureFlagProviderProps {
+  children: React.ReactNode;
+  /** Optional pre-loaded flags (e.g. from the server). */
+  initialFlags?: FeatureFlagMap;
+  /** Definitions to evaluate. Defaults to DEFAULT_FLAGS. */
+  definitions?: FeatureFlagDefinition[];
+}
+
+export function FeatureFlagProvider({
+  children,
+  initialFlags,
+  definitions = DEFAULT_FLAGS,
+}: FeatureFlagProviderProps) {
+  const [remoteFlags, setRemoteFlags] = useState<FeatureFlagMap>(initialFlags ?? {});
+  const [overrides, setOverrides] = useState<FeatureFlagMap>({});
+  const [isLoading, setIsLoading] = useState(!initialFlags);
+  const [error, setError] = useState<Error | null>(null);
+  const sessionIdRef = useRef<string>('server');
+  const definitionsRef = useRef(definitions);
+  definitionsRef.current = definitions;
+
+  useEffect(() => {
+    sessionIdRef.current = getSessionId();
+    setOverrides(readOverrides());
+  }, []);
+
+  const loadFlags = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const flags = await fetchRemoteFlags();
+      setRemoteFlags((prev) => ({ ...prev, ...flags }));
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error('Failed to load feature flags'));
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    if (initialFlags) return;
+    void loadFlags();
+  }, [initialFlags, loadFlags]);
+
+  const flags = useMemo<FeatureFlagMap>(() => {
+    const result: FeatureFlagMap = {};
+    for (const definition of definitionsRef.current) {
+      result[definition.key] = evaluateFlag(
+        definition,
+        remoteFlags[definition.key],
+        sessionIdRef.current,
+      );
+    }
+    // Include any remote flags not covered by definitions.
+    for (const [key, value] of Object.entries(remoteFlags)) {
+      if (!(key in result)) result[key] = value;
+    }
+    // Apply local overrides last (flag control UI).
+    return { ...result, ...overrides };
+  }, [remoteFlags, overrides]);
+
+  // Emit exposure events once per flag per session.
+  useEffect(() => {
+    if (isLoading) return;
+    for (const [key, value] of Object.entries(flags)) {
+      if (!hasTrackedExposure(key)) {
+        trackFeatureFlagExposure(key, value);
+      }
+    }
+  }, [flags, isLoading]);
+
+  const setFlag = useCallback((key: string, value: FeatureFlagValue) => {
+    setOverrides((prev) => {
+      const next = { ...prev, [key]: value };
+      writeOverrides(next);
+      return next;
+    });
+  }, []);
+
+  const getFlag = useCallback(
+    (key: string, fallback: FeatureFlagValue = false): FeatureFlagValue => {
+      if (key in flags) return flags[key];
+      const definition = definitionsRef.current.find((d) => d.key === key);
+      if (definition) {
+        return evaluateFlag(definition, undefined, sessionIdRef.current);
+      }
+      return fallback;
+    },
+    [flags],
+  );
+
+  const value = useMemo<FeatureFlagContextValue>(
+    () => ({
+      flags,
+      isLoading,
+      error,
+      refresh: loadFlags,
+      setFlag,
+      getFlag,
+    }),
+    [flags, isLoading, error, loadFlags, setFlag, getFlag],
+  );
+
+  return <FeatureFlagContext.Provider value={value}>{children}</FeatureFlagContext.Provider>;
+}
+
+function useFeatureFlagContext(): FeatureFlagContextValue {
+  const context = useContext(FeatureFlagContext);
+  if (!context) {
+    throw new Error('useFeatureFlag must be used within a FeatureFlagProvider');
+  }
+  return context;
+}
+
+/** Evaluate a single feature flag. */
+export function useFeatureFlag<T extends FeatureFlagValue = boolean>(
+  key: string,
+  fallback?: T,
+): T {
+  const { getFlag } = useFeatureFlagContext();
+  return getFlag(key, fallback) as T;
+}
+
+/** Access the full flag map and helpers. */
+export function useFeatureFlags(): FeatureFlagContextValue {
+  return useFeatureFlagContext();
+}
+
+export default FeatureFlagProvider;
\ No newline at end of file
diff --git a/src/lib/analytics.ts b/src/lib/analytics.ts
new file mode 100644
index 00000000..0b1e0620
--- /dev/null
+++ b/src/lib/analytics.ts
@@ -0,0 +1,57 @@
+/**
+ * Lightweight analytics helper.
+ *
+ * Provides a typed `trackEvent` function that safely no-ops when no analytics
+ * provider is available (e.g. during SSR, tests, or when analytics is disabled).
+ * Also exposes specific helpers for help content and feature flag exposure.
+ */
+
+export type AnalyticsProps = Record<string, unknown>;
+
+export interface AnalyticsProvider {
+  track: (name: string, props?: AnalyticsProps) => void;
+}
+
+let provider: AnalyticsProvider | null = null;
+
+/**
+ * Register (or clear) the analytics provider. Passing `null` disables tracking.
+ */
+export function setAnalyticsProvider(next: AnalyticsProvider | null): void {
+  provider = next;
+}
+
+/**
+ * Returns true when an analytics provider is currently registered.
+ */
+export function isAnalyticsAvailable(): boolean {
+  return provider !== null;
+}
+
+/**
+ * Track a generic event. No-ops when analytics is unavailable.
+ */
+export function trackEvent(name: string, props?: AnalyticsProps): void {
+  if (!provider) {
+    return;
+  }
+  try {
+    provider.track(name, props);
+  } catch {
+    // Analytics must never break the app.
+  }
+}
+
+/**
+ * Track that a contextual help entry was opened.
+ */
+export function trackHelpOpened(helpKey: string): void {
+  trackEvent('help_opened', { helpKey });
+}
+
+/**
+ * Track that a user was exposed to a feature flag variant.
+ */
+export function trackFeatureFlagExposure(flagKey: string, variant: string): void {
+  trackEvent('feature_flag_exposure', { flagKey, variant });
+}
\ No newline at end of file
diff --git a/src/lib/config.ts b/src/lib/config.ts
index 84a271b0..f7543b84 100644
--- a/src/lib/config.ts
+++ b/src/lib/config.ts
@@ -15,10 +15,146 @@ export const RPC_URL =
 /** StellarSplit contract ID used for on-chain calls and event filtering. */
 export const contractId = process.env.NEXT_PUBLIC_CONTRACT_ID ?? "";
 
+/**
+ * Feature flag value.
+ * - `boolean`: simple on/off flag.
+ * - `number` (0-100): percentage-based gradual rollout.
+ * - `object`: advanced flag with optional percentage rollout and explicit allow/deny lists.
+ */
+export type FeatureFlagValue =
+  | boolean
+  | number
+  | {
+      enabled?: boolean;
+      /** Percentage (0-100) of users for whom the flag is enabled. */
+      percentage?: number;
+      /** User ids that always see the flag enabled. */
+      allowlist?: string[];
+      /** User ids that never see the flag enabled. */
+      denylist?: string[];
+    };
+
+export type FeatureFlags = Record<string, FeatureFlagValue>;
+
+/** Context used to evaluate a feature flag for a given user/session. */
+export interface FlagContext {
+  /** Stable identifier for the user (used for percentage rollout bucketing). */
+  userId?: string;
+  /** Optional arbitrary attributes for future targeting rules. */
+  attributes?: Record<string, string | number | boolean>;
+}
+
+/** Default flags used when no override is provided via env. */
+export const DEFAULT_FEATURE_FLAGS: FeatureFlags = {
+  /** Example: gradual rollout of a new dashboard. */
+  newDashboard: { enabled: true, percentage: 0 },
+  /** Example: A/B test for the split creation flow. */
+  splitCreationV2: { enabled: true, percentage: 10 },
+  /** Example: analytics instrumentation toggle. */
+  analytics: true,
+};
+
+/**
+ * Parse a JSON feature flag map from an env string.
+ * Returns `null` when the input is missing or invalid so callers can fall back to defaults.
+ */
+function parseFeatureFlags(raw: string | undefined): FeatureFlags | null {
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed as FeatureFlags;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Feature flags resolved from `NEXT_PUBLIC_FEATURE_FLAGS` (JSON), merged over defaults.
+ * Env-provided flags override matching default keys.
+ */
+export const FEATURE_FLAGS: FeatureFlags = {
+  ...DEFAULT_FEATURE_FLAGS,
+  ...(parseFeatureFlags(process.env.NEXT_PUBLIC_FEATURE_FLAGS) ?? {}),
+};
+
+/**
+ * Stable, deterministic 32-bit hash of a string (FNV-1a).
+ * Used to bucket users for percentage-based rollouts so the same user
+ * consistently receives the same flag evaluation.
+ */
+export function stableHash(input: string): number {
+  let hash = 0x811c9dc5;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 0x01000193);
+  }
+  // Convert to unsigned 32-bit integer.
+  return hash >>> 0;
+}
+
+/** Map a user id to a bucket in the range [0, 100). */
+function bucketFor(userId: string, key: string): number {
+  // Include the flag key so different flags bucket users independently.
+  return stableHash(`${key}:${userId}`) % 100;
+}
+
+/**
+ * Evaluate a feature flag.
+ *
+ * @param key     Flag name.
+ * @param context Optional evaluation context (userId enables percentage rollout).
+ * @returns `true` when the flag is enabled for the given context.
+ */
+export function isFlagEnabled(key: string, context?: FlagContext): boolean {
+  const flag = FEATURE_FLAGS[key];
+  if (flag === undefined) return false;
+
+  // Simple boolean flag.
+  if (typeof flag === "boolean") return flag;
+
+  // Percentage-only flag.
+  if (typeof flag === "number") {
+    return evaluatePercentage(flag, key, context);
+  }
+
+  // Advanced object flag.
+  const userId = context?.userId;
+
+  if (userId && flag.denylist?.includes(userId)) return false;
+  if (userId && flag.allowlist?.includes(userId)) return true;
+
+  if (flag.enabled === false) return false;
+
+  if (typeof flag.percentage === "number") {
+    return evaluatePercentage(flag.percentage, key, context);
+  }
+
+  return flag.enabled ?? false;
+}
+
+function evaluatePercentage(
+  percentage: number,
+  key: string,
+  context?: FlagContext,
+): boolean {
+  if (percentage <= 0) return false;
+  if (percentage >= 100) return true;
+
+  const userId = context?.userId;
+  // Without a stable user id we cannot bucket deterministically; default to off.
+  if (!userId) return false;
+
+  return bucketFor(userId, key) < percentage;
+}
+
 export const config = {
   network: STELLAR_NETWORK,
   rpcUrl: RPC_URL,
   contractId,
+  featureFlags: FEATURE_FLAGS,
 } as const;
 
-export default config;
+export default config;
\ No newline at end of file