Feature Flags at Scale: Implementation Patterns and Platform Comparison

interface ReleaseFlag {  key: 'new-checkout-flow';  type: 'release';  defaultValue: false;  temporary: true;  expiresAt: '2025-03-01'; // Set expiration when creating}

interface ExperimentFlag {  key: 'cta-button-color-experiment';  type: 'experiment';  variations: {    control: { color: 'blue' },    treatmentA: { color: 'green' },    treatmentB: { color: 'red' }  };  temporary: true;  expiresAt: '2025-02-15';}

interface OpsFlag {  key: 'enable-recommendation-engine';  type: 'ops';  defaultValue: true;  permanent: true;  purpose: 'Disable recommendation engine during high load';}

interface PermissionFlag {  key: 'premium-analytics';  type: 'permission';  defaultValue: false;  permanent: true;  targetingRules: {    subscriptionTier: ['premium', 'enterprise']  };}

import { init, LDClient, LDFlagSet } from '@launchdarkly/node-server-sdk';
// Singleton client initializationlet ldClient: LDClient | null = null;
export async function initializeLaunchDarkly(): Promise<LDClient> {  if (ldClient) {    return ldClient;  }
  ldClient = init(process.env.LAUNCHDARKLY_SDK_KEY!, {    // Performance optimization: reduce network calls    streamInitialReconnectDelay: 1000,    // Local evaluation for lower latency    sendEvents: true,    // Timeout configuration    timeout: 5,  });
  await ldClient.waitForInitialization({ timeout: 5 });  console.log('LaunchDarkly initialized');
  return ldClient;}

// User context for targetinginterface UserContext {  key: string;  email?: string;  country?: string;  customAttributes?: Record<string, any>;}
// Type-safe flag evaluationexport async function evaluateFlag<T>(  flagKey: string,  user: UserContext,  defaultValue: T): Promise<T> {  const client = await initializeLaunchDarkly();
  const ldUser = {    key: user.key,    email: user.email,    country: user.country,    custom: user.customAttributes,  };
  return client.variation(flagKey, ldUser, defaultValue);}

import { Request, Response, NextFunction } from 'express';
export async function checkFeatureFlag(flagKey: string) {  return async (req: Request, res: Response, next: NextFunction) => {    const user = {      key: req.user?.id || 'anonymous',      email: req.user?.email,      country: req.headers['cloudfront-viewer-country'] as string,    };
    const isEnabled = await evaluateFlag(flagKey, user, false);
    if (!isEnabled) {      return res.status(403).json({        error: 'Feature not available'      });    }
    next();  };}
// Usage in routeapp.post('/api/checkout',  checkFeatureFlag('new-checkout-flow'),  async (req, res) => {    // New checkout implementation  });

import { initialize, isEnabled, getVariant } from 'unleash-client';
const unleash = initialize({  url: process.env.UNLEASH_URL!,  appName: 'order-service',  instanceId: process.env.HOSTNAME || 'local',  customHeaders: {    Authorization: process.env.UNLEASH_API_TOKEN!,  },  // Performance: local caching  refreshInterval: 15000, // 15 seconds  metricsInterval: 60000, // 1 minute});
// Wait for SDK to be readyunleash.on('ready', () => {  console.log('Unleash client ready');});
unleash.on('error', (err) => {  console.error('Unleash error:', err);});

interface UnleashContext {  userId?: string;  sessionId?: string;  remoteAddress?: string;  properties?: Record<string, string>;}
export function checkFlag(  flagName: string,  context: UnleashContext,  defaultValue = false): boolean {  return isEnabled(flagName, context, defaultValue);}
export function getFlagVariant(  flagName: string,  context: UnleashContext): { name: string; payload?: any } {  return getVariant(flagName, context);}

export async function processOrder(orderId: string, userId: string) {  const context = {    userId,    sessionId: orderId,    properties: {      userTier: await getUserTier(userId),      region: await getUserRegion(userId),    },  };
  // Simple on/off flag  const useNewPaymentGateway = checkFlag(    'new-payment-gateway',    context,    false  );
  // Multivariate flag for A/B testing  const checkoutVariant = getFlagVariant('checkout-layout', context);
  if (useNewPaymentGateway) {    return processWithNewGateway(orderId, checkoutVariant);  } else {    return processWithLegacyGateway(orderId);  }}

import { AppConfigDataClient, StartConfigurationSessionCommand, GetLatestConfigurationCommand } from '@aws-sdk/client-appconfigdata';
interface FeatureFlagConfig {  flags: Record<string, {    enabled: boolean;    attributes?: Record<string, any>;  }>;  version: string;}
let cachedConfig: FeatureFlagConfig | null = null;let configToken: string | null = null;
export async function initializeAppConfig() {  const client = new AppConfigDataClient({ region: process.env.AWS_REGION });
  const sessionCommand = new StartConfigurationSessionCommand({    ApplicationIdentifier: process.env.APPCONFIG_APPLICATION!,    EnvironmentIdentifier: process.env.APPCONFIG_ENVIRONMENT!,    ConfigurationProfileIdentifier: process.env.APPCONFIG_PROFILE!,  });
  const response = await client.send(sessionCommand);  configToken = response.InitialConfigurationToken!;}
export async function fetchFeatureFlags(): Promise<FeatureFlagConfig> {  if (!configToken) {    await initializeAppConfig();  }
  const client = new AppConfigDataClient({ region: process.env.AWS_REGION });
  const command = new GetLatestConfigurationCommand({    ConfigurationToken: configToken!,  });
  const response = await client.send(command);  configToken = response.NextPollConfigurationToken!;
  if (response.Configuration) {    const configString = new TextDecoder().decode(response.Configuration);    cachedConfig = JSON.parse(configString);  }
  return cachedConfig!;}

export const handler = async (event: any) => {  const config = await fetchFeatureFlags();
  const userId = event.requestContext.authorizer.claims.sub;
  // Simple flag check  const isNewFeatureEnabled = config.flags['new-dashboard']?.enabled || false;
  // Attribute-based targeting  const userTier = await getUserTier(userId);  const premiumFeaturesFlag = config.flags['premium-features'];  const hasPremiumAccess =    premiumFeaturesFlag?.enabled &&    premiumFeaturesFlag?.attributes?.allowedTiers?.includes(userTier);
  if (isNewFeatureEnabled && hasPremiumAccess) {    return {      statusCode: 200,      body: JSON.stringify({ dashboard: 'new', premium: true }),    };  }
  return {    statusCode: 200,    body: JSON.stringify({ dashboard: 'legacy', premium: false }),  };};

interface TargetingRule {  attribute: string;  operator: 'equals' | 'contains' | 'greaterThan' | 'lessThan' | 'regex' | 'in';  values: any[];}
interface Segment {  name: string;  rules: TargetingRule[];  rolloutPercentage?: number;}
interface FeatureFlagDefinition {  key: string;  defaultValue: boolean;  segments: Segment[];}

class FeatureFlagEvaluator {  evaluateRule(rule: TargetingRule, context: Record<string, any>): boolean {    const attributeValue = context[rule.attribute];
    if (attributeValue === undefined) {      return false;    }
    switch (rule.operator) {      case 'equals':        return attributeValue === rule.values[0];
      case 'in':        return rule.values.includes(attributeValue);
      case 'contains':        return String(attributeValue).includes(String(rule.values[0]));
      case 'greaterThan':        return Number(attributeValue) > Number(rule.values[0]);
      case 'lessThan':        return Number(attributeValue) < Number(rule.values[0]);
      case 'regex':        const pattern = new RegExp(rule.values[0]);        return pattern.test(String(attributeValue));
      default:        return false;    }  }
  evaluateSegment(segment: Segment, context: Record<string, any>): boolean {    // All rules in segment must match (AND logic)    const rulesMatch = segment.rules.every(rule =>      this.evaluateRule(rule, context)    );
    if (!rulesMatch) {      return false;    }
    // Apply percentage rollout if specified    if (segment.rolloutPercentage !== undefined) {      const hash = this.hashUserId(context.userId);      const bucket = hash % 100;      return bucket < segment.rolloutPercentage;    }
    return true;  }
  evaluateFlag(    flag: FeatureFlagDefinition,    context: Record<string, any>  ): boolean {    // Check segments in order, return first match    for (const segment of flag.segments) {      if (this.evaluateSegment(segment, context)) {        return true;      }    }
    return flag.defaultValue;  }
  // Consistent hashing for percentage rollouts  private hashUserId(userId: string): number {    let hash = 0;    for (let i = 0; i < userId.length; i++) {      const char = userId.charCodeAt(i);      hash = ((hash << 5) - hash) + char;      hash = hash & hash; // Convert to 32-bit integer    }    return Math.abs(hash);  }}

const evaluator = new FeatureFlagEvaluator();
const premiumFeatureFlag: FeatureFlagDefinition = {  key: 'premium-analytics',  defaultValue: false,  segments: [    {      name: 'Internal employees',      rules: [        { attribute: 'email', operator: 'contains', values: ['@company.com'] }      ],    },    {      name: 'Premium tier users',      rules: [        { attribute: 'subscriptionTier', operator: 'in', values: ['premium', 'enterprise'] }      ],    },    {      name: 'Beta users gradual rollout',      rules: [        { attribute: 'betaOptIn', operator: 'equals', values: [true] }      ],      rolloutPercentage: 20, // 20% of beta users    },  ],};
const userContext = {  userId: 'user-123',  email: '[email protected]',  subscriptionTier: 'premium',  betaOptIn: true,};
const isEnabled = evaluator.evaluateFlag(premiumFeatureFlag, userContext);

import { init, LDClient } from '@launchdarkly/node-server-sdk';import * as Amplitude from '@amplitude/node';
interface ExperimentContext {  userId: string;  userProperties: Record<string, any>;  eventProperties?: Record<string, any>;}
class FeatureFlagAnalytics {  private ldClient: LDClient;  private amplitudeClient: Amplitude.Types.NodeClient;
  constructor(ldKey: string, amplitudeKey: string) {    this.ldClient = init(ldKey);    this.amplitudeClient = Amplitude.init(amplitudeKey);  }
  async evaluateExperiment(    experimentKey: string,    context: ExperimentContext,    defaultVariation: string  ): Promise<string> {    const ldContext = {      key: context.userId,      custom: context.userProperties,    };
    // Get variation from LaunchDarkly    const variation = await this.ldClient.variation(      experimentKey,      ldContext,      defaultVariation    );
    // Track experiment exposure in Amplitude    await this.amplitudeClient.logEvent({      event_type: 'Experiment Viewed',      user_id: context.userId,      event_properties: {        experiment_name: experimentKey,        variation_name: variation,        ...context.eventProperties,      },      user_properties: context.userProperties,    });
    return variation;  }
  async trackConversion(    experimentKey: string,    context: ExperimentContext,    conversionMetric: string,    value?: number  ) {    await this.amplitudeClient.logEvent({      event_type: conversionMetric,      user_id: context.userId,      event_properties: {        experiment_name: experimentKey,        value,        ...context.eventProperties,      },      user_properties: context.userProperties,    });  }}

const analytics = new FeatureFlagAnalytics(  process.env.LAUNCHDARKLY_KEY!,  process.env.AMPLITUDE_KEY!);
export async function renderCheckoutButton(userId: string) {  const context = {    userId,    userProperties: {      accountAge: await getAccountAge(userId),      previousPurchases: await getPurchaseCount(userId),    },  };
  // Get button color variation (control, green, red)  const buttonColor = await analytics.evaluateExperiment(    'checkout-button-color',    context,    'control' // Default blue button  );
  return {    color: buttonColor === 'control' ? 'blue' : buttonColor,    experimentKey: 'checkout-button-color',  };}
export async function handleCheckoutClick(userId: string, experimentKey: string) {  const context = {    userId,    userProperties: {},    eventProperties: {      page: 'checkout',    },  };
  await analytics.trackConversion(    experimentKey,    context,    'Checkout Button Clicked'  );}
export async function handlePurchaseComplete(  userId: string,  experimentKey: string,  amount: number) {  const context = {    userId,    userProperties: {},    eventProperties: {      purchaseAmount: amount,    },  };
  await analytics.trackConversion(    experimentKey,    context,    'Purchase Completed',    amount  );}

import { EventEmitter } from 'events';
interface CircuitBreakerConfig {  flagKey: string;  errorThreshold: number; // Percentage of errors before opening  timeWindow: number; // Time window in ms  checkInterval: number; // How often to check flag state}
enum CircuitState {  CLOSED = 'CLOSED', // Normal operation  OPEN = 'OPEN',     // Circuit breaker triggered  HALF_OPEN = 'HALF_OPEN', // Testing if service recovered}
class FeatureFlagCircuitBreaker extends EventEmitter {  private state: CircuitState = CircuitState.CLOSED;  private errors: number[] = [];  private requests: number[] = [];  private flagEnabled: boolean = true;
  constructor(    private config: CircuitBreakerConfig,    private flagClient: any  ) {    super();    this.startFlagMonitoring();  }
  private startFlagMonitoring() {    setInterval(async () => {      // Check if flag was manually disabled (kill switch)      this.flagEnabled = await this.flagClient.variation(        this.config.flagKey,        { key: 'system' },        true      );
      if (!this.flagEnabled && this.state !== CircuitState.OPEN) {        this.openCircuit('Manual kill switch activated');      } else if (this.flagEnabled && this.state === CircuitState.OPEN) {        this.halfOpenCircuit();      }    }, this.config.checkInterval);  }
  async executeWithCircuitBreaker<T>(    operation: () => Promise<T>,    fallback: () => T  ): Promise<T> {    // If circuit is open or flag disabled, use fallback    if (this.state === CircuitState.OPEN || !this.flagEnabled) {      return fallback();    }
    const now = Date.now();    this.requests.push(now);
    try {      const result = await operation();
      // Success in HALF_OPEN state closes circuit      if (this.state === CircuitState.HALF_OPEN) {        this.closeCircuit();      }
      return result;    } catch (error) {      this.errors.push(now);      this.checkErrorThreshold();      throw error;    } finally {      this.cleanupOldMetrics(now);    }  }
  private checkErrorThreshold() {    const now = Date.now();    const recentRequests = this.requests.filter(      t => now - t < this.config.timeWindow    );    const recentErrors = this.errors.filter(      t => now - t < this.config.timeWindow    );
    if (recentRequests.length === 0) return;
    const errorRate = (recentErrors.length / recentRequests.length) * 100;
    if (errorRate >= this.config.errorThreshold) {      this.openCircuit(`Error rate ${errorRate.toFixed(2)}% exceeded threshold`);    }  }
  private openCircuit(reason: string) {    this.state = CircuitState.OPEN;    this.emit('circuit-opened', { reason, flagKey: this.config.flagKey });    console.error(`Circuit breaker OPEN: ${reason}`);  }
  private halfOpenCircuit() {    this.state = CircuitState.HALF_OPEN;    this.emit('circuit-half-open', { flagKey: this.config.flagKey });    console.log('Circuit breaker HALF_OPEN: testing recovery');  }
  private closeCircuit() {    this.state = CircuitState.CLOSED;    this.errors = [];    this.emit('circuit-closed', { flagKey: this.config.flagKey });    console.log('Circuit breaker CLOSED: service recovered');  }
  private cleanupOldMetrics(now: number) {    this.requests = this.requests.filter(      t => now - t < this.config.timeWindow    );    this.errors = this.errors.filter(      t => now - t < this.config.timeWindow    );  }
  getState(): CircuitState {    return this.state;  }}

const recommendationEngineBreaker = new FeatureFlagCircuitBreaker(  {    flagKey: 'enable-recommendation-engine',    errorThreshold: 50, // 50% error rate    timeWindow: 60000, // 1 minute    checkInterval: 5000, // Check flag every 5 seconds  },  ldClient);
// Monitor circuit breaker eventsrecommendationEngineBreaker.on('circuit-opened', ({ reason }) => {  console.error('ALERT: Recommendation engine circuit breaker opened:', reason);  sendPagerDutyAlert('Recommendation engine disabled', reason);});
export async function getRecommendations(userId: string) {  return recommendationEngineBreaker.executeWithCircuitBreaker(    // Primary operation: call recommendation engine    async () => {      const response = await fetch(`https://api.recommendations.com/users/${userId}`);      if (!response.ok) throw new Error('Recommendation API failed');      return response.json();    },    // Fallback: return popular items    () => {      return getPopularItems(); // Simple fallback    }  );}

interface FlagMetadata {  key: string;  type: 'release' | 'experiment' | 'ops' | 'permission';  createdAt: Date;  createdBy: string;  expiresAt?: Date;  status: 'active' | 'inactive' | 'launched' | 'deprecated';  evaluationCount: number;  lastEvaluated?: Date;}
class FlagLifecycleManager {  private metadata: Map<string, FlagMetadata> = new Map();  private readonly INACTIVE_THRESHOLD_DAYS = 30;  private readonly STALE_FLAG_THRESHOLD_DAYS = 90;
  constructor(private flagClient: any) {    this.startLifecycleMonitoring();  }
  async evaluateFlag(    flagKey: string,    context: any,    defaultValue: any  ): Promise<any> {    const value = await this.flagClient.variation(flagKey, context, defaultValue);
    // Update metadata    const metadata = this.metadata.get(flagKey);    if (metadata) {      metadata.evaluationCount++;      metadata.lastEvaluated = new Date();    }
    return value;  }
  registerFlag(metadata: Omit<FlagMetadata, 'evaluationCount' | 'lastEvaluated'>) {    this.metadata.set(metadata.key, {      ...metadata,      evaluationCount: 0,    });  }
  findStaleFlags(): FlagMetadata[] {    const now = new Date();    const staleFlags: FlagMetadata[] = [];
    this.metadata.forEach(flag => {      // Skip permanent flags (ops, permission)      if (flag.type === 'ops' || flag.type === 'permission') {        return;      }
      // Check if expired      if (flag.expiresAt && now > flag.expiresAt) {        staleFlags.push(flag);        return;      }
      // Check if inactive (no evaluations in 30 days)      if (flag.lastEvaluated) {        const daysSinceEvaluation =          (now.getTime() - flag.lastEvaluated.getTime()) / (1000 * 60 * 60 * 24);
        if (daysSinceEvaluation > this.INACTIVE_THRESHOLD_DAYS) {          flag.status = 'inactive';          staleFlags.push(flag);        }      }
      // Check if flag is old and never evaluated      const flagAge =        (now.getTime() - flag.createdAt.getTime()) / (1000 * 60 * 60 * 24);
      if (flagAge > this.STALE_FLAG_THRESHOLD_DAYS && flag.evaluationCount === 0) {        staleFlags.push(flag);      }    });
    return staleFlags;  }
  async generateCleanupReport(): Promise<string> {    const staleFlags = this.findStaleFlags();    const report: string[] = [      '# Feature Flag Cleanup Report',      `Generated: ${new Date().toISOString()}`,      '',      '## Flags Ready for Removal',      '',    ];
    for (const flag of staleFlags) {      report.push(`### ${flag.key}`);      report.push(`- Type: ${flag.type}`);      report.push(`- Created: ${flag.createdAt.toISOString()}`);      report.push(`- Status: ${flag.status}`);      report.push(`- Evaluations: ${flag.evaluationCount}`);      report.push(`- Last evaluated: ${flag.lastEvaluated?.toISOString() || 'Never'}`);
      if (flag.expiresAt) {        report.push(`- Expired: ${flag.expiresAt.toISOString()}`);      }
      report.push('');    }
    return report.join('\n');  }
  private startLifecycleMonitoring() {    // Weekly cleanup check    setInterval(async () => {      const report = await this.generateCleanupReport();      console.log(report);      // In production: send to Slack, create Jira ticket, etc.    }, 7 * 24 * 60 * 60 * 1000); // Weekly  }}

export class FeatureToggle {  constructor(private flagClient: any) {}
  async withFeature<T>(    flagKey: string,    context: any,    newImplementation: () => Promise<T>,    legacyImplementation: () => Promise<T>  ): Promise<T> {    const isEnabled = await this.flagClient.variation(      flagKey,      context,      false // Default: disabled    );
    if (isEnabled) {      try {        return await newImplementation();      } catch (error) {        console.error(`Feature ${flagKey} failed, falling back:`, error);        // Automatic fallback on error        return await legacyImplementation();      }    }
    return await legacyImplementation();  }}

const toggle = new FeatureToggle(ldClient);
export async function processPayment(orderId: string, userId: string) {  const context = { key: userId };
  return toggle.withFeature(    'new-payment-processor',    context,    // New implementation (under development)    async () => {      // Incomplete feature can be merged to main      // because it's behind flag (disabled by default)      return newPaymentProcessor.process(orderId);    },    // Legacy implementation (production)    async () => {      return legacyPaymentProcessor.process(orderId);    }  );}

class MockFlagClient {  private flags: Map<string, any> = new Map();
  setFlag(key: string, value: any) {    this.flags.set(key, value);  }
  async variation(key: string, context: any, defaultValue: any): Promise<any> {    return this.flags.get(key) ?? defaultValue;  }
  reset() {    this.flags.clear();  }}

describe('Payment Processing', () => {  let mockFlags: MockFlagClient;  let paymentService: PaymentService;
  beforeEach(() => {    mockFlags = new MockFlagClient();    paymentService = new PaymentService(mockFlags);  });
  describe('with new payment processor ENABLED', () => {    beforeEach(() => {      mockFlags.setFlag('new-payment-processor', true);    });
    it('should use new payment processor', async () => {      const result = await paymentService.processPayment('order-123', 'user-456');      expect(result.processor).toBe('new');    });
    it('should handle new processor errors gracefully', async () => {      mockNewProcessor.process = jest.fn().mockRejectedValue(new Error('API Error'));
      // Should fallback to legacy      const result = await paymentService.processPayment('order-123', 'user-456');      expect(result.processor).toBe('legacy');    });  });
  describe('with new payment processor DISABLED', () => {    beforeEach(() => {      mockFlags.setFlag('new-payment-processor', false);    });
    it('should use legacy payment processor', async () => {      const result = await paymentService.processPayment('order-123', 'user-456');      expect(result.processor).toBe('legacy');    });
    it('should not call new processor', async () => {      const newProcessorSpy = jest.spyOn(mockNewProcessor, 'process');      await paymentService.processPayment('order-123', 'user-456');      expect(newProcessorSpy).not.toHaveBeenCalled();    });  });});