/feature-flag-manager

DevsForge Feature Flag Manager

DevsForge intelligent feature flag management system that orchestrates progressive feature rollouts, A/B testing, canary releases, and kill switches with comprehensive analytics, team coordination, and risk mitigation strategies.

Purpose

Transform feature deployment from risky big-bang releases to controlled, data-driven rollouts that enable rapid iteration, minimize blast radius, and provide instant rollback capabilities across distributed systems.

Features

• Flag Lifecycle Management: Create, configure, and retire feature flags with governance
• Progressive Rollouts: Gradual feature deployment with user targeting and percentage-based distribution
• A/B Testing: Experimentation framework with statistical significance tracking
• Kill Switches: Emergency feature disable with instant propagation
• User Targeting: Sophisticated targeting rules based on attributes, segments, and context
• Analytics Integration: Real-time feature usage metrics and conversion tracking
• Multi-Environment Support: Consistent flag management across dev, staging, and production
• Audit Trail: Complete change history for compliance and debugging

Usage

/feature-flag-manager [command] [options]

Target: $ARGUMENTS (if specified, otherwise manage all flags in current environment)

Flag Management Commands

Create Feature Flag:

/feature-flag-manager create --name=new-checkout-flow --type=release --environments=all

Creates new feature flag with:

• Unique flag key generation
• Default variation configuration
• Environment-specific settings
• Access control and permissions
• Documentation requirements
• Review and approval workflow
• Integration with issue tracker
• Automated test flag generation

Update Flag Configuration:

/feature-flag-manager update --flag=new-checkout-flow --targeting=enabled --rules=beta-users

Updates flag configuration including:

• Targeting rules and prerequisites
• User segment assignments
• Percentage rollout adjustments
• Variation value modifications
• Fallback configuration
• Environment synchronization
• Change tracking and audit
• Team notification system

Delete Feature Flag:

/feature-flag-manager delete --flag=old-feature --check-usage --archive

Safely removes feature flags:

• Usage analysis across codebase
• Dependent feature detection
• Staged deletion process
• Code cleanup suggestions
• Archive for audit trail
• Team notification
• Technical debt tracking
• Migration guide generation

Rollout Strategies

Percentage Rollout:

/feature-flag-manager rollout --flag=new-ui --percentage=25 --increment=25 --interval=1h

Implements progressive rollout:

• Initial percentage deployment
• Automated incremental increases
• Monitoring-based progression
• Error rate threshold checks
• Automatic pause on issues
• Rollback triggers
• User consistency (sticky assignments)
• Schedule-based progression

Targeted Rollout:

/feature-flag-manager rollout --flag=premium-features --segment=enterprise-users --context=subscription-tier

Deploys to specific user segments:

• User attribute-based targeting
• Custom segment definitions
• Multi-condition rule sets
• Geographic targeting
• Device/platform targeting
• Account-level overrides
• Test user exclusions
• Gradual segment expansion

Ring Deployment:

/feature-flag-manager rollout --flag=api-v2 --strategy=rings --rings="internal,beta,ga"

Implements ring-based deployment:

• Internal team ring (5% of users)
• Beta user ring (20% of users)
• General availability ring (100% of users)
• Automated progression gates
• Ring-specific monitoring
• Quality gates between rings
• Fast ring rollback capability
• Documentation updates per ring

A/B Testing

Create Experiment:

/feature-flag-manager experiment create --name=checkout-optimization --variants=A,B --split=50/50 --duration=14d

Sets up A/B test with:

• Variant definition and allocation
• Statistical power calculation
• Sample size requirements
• Success metric definition
• Control group preservation
• Random assignment algorithm
• Consistent user experience
• Early stopping criteria

Analyze Results:

/feature-flag-manager experiment analyze --name=checkout-optimization --metrics=conversion,revenue

Provides statistical analysis:

• Conversion rate comparison
• Statistical significance testing
• Confidence interval calculation
• Revenue impact analysis
• User engagement metrics
• Segment-based breakdowns
• Visualization and reporting
• Winner recommendation

Graduate Experiment:

/feature-flag-manager experiment graduate --name=checkout-optimization --winner=B --cleanup-code

Completes experiment lifecycle:

• Winner deployment to 100%
• Loser variant removal
• Code cleanup automation
• A/B test flag removal
• Documentation updates
• Team communication
• Learning documentation
• Next iteration planning

Kill Switch Operations

Emergency Disable:

/feature-flag-manager kill-switch --flag=problematic-feature --immediate --notify-team

Instantly disables feature:

• Zero-downtime flag flip
• Immediate CDN/cache invalidation
• Real-time client notification
• Automatic team alerts
• Incident documentation
• Rollback verification
• Impact assessment
• Root cause investigation trigger

Scheduled Disable:

/feature-flag-manager schedule disable --flag=holiday-promotion --date=2024-12-26 --time=00:00:00

Plans feature deactivation:

• Scheduled flag changes
• Timezone-aware execution
• Pre-execution notifications
• Automated verification
• Rollback plan preparation
• Communication automation
• Metric baseline capture
• Post-disable monitoring

Integration Platforms

LaunchDarkly Integration

Configuration:

// launchdarkly-config.js
import * as LaunchDarkly from 'launchdarkly-node-server-sdk';

const ldClient = LaunchDarkly.init(process.env.LAUNCHDARKLY_SDK_KEY, {
  sendEvents: true,
  allAttributesPrivate: false,
  stream: true,
  offline: false
});

await ldClient.waitForInitialization();

export async function evaluateFlag(flagKey, user, defaultValue) {
  try {
    const context = {
      kind: 'user',
      key: user.id,
      email: user.email,
      custom: {
        accountTier: user.subscription,
        signupDate: user.createdAt,
        region: user.region
      }
    };

    return await ldClient.variation(flagKey, context, defaultValue);
  } catch (error) {
    console.error('Flag evaluation error:', error);
    return defaultValue;
  }
}

React Integration:

import { withLDProvider, useFlags, useLDClient } from 'launchdarkly-react-client-sdk';

function App() {
  const { newCheckoutFlow, premiumFeatures } = useFlags();
  const ldClient = useLDClient();

  useEffect(() => {
    // Track feature usage
    if (newCheckoutFlow) {
      ldClient?.track('checkout-flow-viewed', {
        version: 'new'
      });
    }
  }, [newCheckoutFlow, ldClient]);

  return (
    <div>
      {newCheckoutFlow ? <NewCheckout /> : <LegacyCheckout />}
      {premiumFeatures && <PremiumSection />}
    </div>
  );
}

export default withLDProvider({
  clientSideID: process.env.REACT_APP_LD_CLIENT_ID,
  user: {
    key: userId,
    email: userEmail,
    custom: {
      subscriptionTier: userTier
    }
  }
})(App);

Unleash Integration

Server Configuration:

// unleash-config.js
const { initialize } = require('unleash-client');

const unleash = initialize({
  url: 'https://unleash.example.com/api',
  appName: 'my-application',
  instanceId: process.env.INSTANCE_ID,
  environment: process.env.NODE_ENV,
  customHeaders: {
    Authorization: process.env.UNLEASH_API_TOKEN
  },
  strategies: [
    {
      name: 'gradualRollout',
      implementation: gradualRolloutStrategy
    },
    {
      name: 'userWithId',
      implementation: userTargetingStrategy
    }
  ]
});

unleash.on('ready', () => {
  console.log('Unleash client ready');
});

unleash.on('error', (error) => {
  console.error('Unleash error:', error);
});

function isFeatureEnabled(flagName, context = {}) {
  return unleash.isEnabled(flagName, context, (name, enabled) => {
    // Track feature evaluations
    trackFeatureEvaluation(name, enabled, context);
  });
}

module.exports = { unleash, isFeatureEnabled };

Custom Strategies:

// Custom rollout strategy
const gradualRolloutStrategy = {
  name: 'gradualRollout',
  execute: (context, parameters) => {
    const userId = context.userId;
    const percentage = parseInt(parameters.percentage, 10);

    // Consistent hashing for user assignment
    const hash = murmurhash(userId + parameters.groupId);
    const bucket = hash % 100;

    return bucket < percentage;
  }
};

// User segment strategy
const segmentStrategy = {
  name: 'userSegment',
  execute: (context, parameters) => {
    const userSegment = context.properties?.segment;
    const allowedSegments = parameters.segments.split(',');

    return allowedSegments.includes(userSegment);
  }
};

Split.io Integration

TypeScript Configuration:

// splitio-config.ts
import { SplitFactory } from '@splitsoftware/splitio';

interface UserContext {
  id: string;
  email: string;
  attributes: Record<string, any>;
}

class FeatureFlagService {
  private client: any;
  private isReady: boolean = false;

  async initialize() {
    const factory = SplitFactory({
      core: {
        authorizationKey: process.env.SPLIT_API_KEY!,
        key: 'customer-id'
      },
      scheduler: {
        impressionsRefreshRate: 60
      }
    });

    this.client = factory.client();

    await new Promise((resolve) => {
      this.client.on(this.client.Event.SDK_READY, () => {
        this.isReady = true;
        resolve(true);
      });
    });
  }

  getTreatment(
    flagKey: string,
    user: UserContext,
    attributes?: Record<string, any>
  ): string {
    if (!this.isReady) {
      return 'control';
    }

    return this.client.getTreatment(
      user.id,
      flagKey,
      { ...user.attributes, ...attributes }
    );
  }

  getTreatmentWithConfig(
    flagKey: string,
    user: UserContext
  ): { treatment: string; config: any } {
    const result = this.client.getTreatmentWithConfig(
      user.id,
      flagKey,
      user.attributes
    );

    return {
      treatment: result.treatment,
      config: result.config ? JSON.parse(result.config) : null
    };
  }

  track(
    eventType: string,
    user: UserContext,
    value?: number,
    properties?: Record<string, any>
  ): boolean {
    return this.client.track(
      user.id,
      'user',
      eventType,
      value,
      properties
    );
  }
}

export const featureFlagService = new FeatureFlagService();

Advanced Targeting Rules

User Attribute Targeting

Complex Rule Configuration:

{
  "flag": "premium-dashboard",
  "targeting": {
    "enabled": true,
    "rules": [
      {
        "id": "enterprise-users",
        "conditions": [
          {
            "attribute": "subscription_tier",
            "operator": "equals",
            "value": "enterprise"
          },
          {
            "attribute": "account_age_days",
            "operator": "greater_than",
            "value": 30
          }
        ],
        "variation": "enabled"
      },
      {
        "id": "beta-testers",
        "conditions": [
          {
            "attribute": "user_id",
            "operator": "in_segment",
            "value": "beta-testers-segment"
          }
        ],
        "variation": "enabled",
        "rollout": {
          "percentage": 50
        }
      }
    ],
    "defaultVariation": "disabled"
  }
}

Geographic Targeting

Region-Based Rollout:

const geoTargetingRules = {
  flag: 'new-payment-provider',
  rules: [
    {
      name: 'US-East-Rollout',
      conditions: [
        { attribute: 'country', operator: 'equals', value: 'US' },
        { attribute: 'region', operator: 'in', value: ['us-east-1', 'us-east-2'] }
      ],
      variation: 'new-provider',
      percentage: 100
    },
    {
      name: 'US-West-Canary',
      conditions: [
        { attribute: 'country', operator: 'equals', value: 'US' },
        { attribute: 'region', operator: 'in', value: ['us-west-1', 'us-west-2'] }
      ],
      variation: 'new-provider',
      percentage: 10
    },
    {
      name: 'EU-Regions',
      conditions: [
        { attribute: 'country', operator: 'in', value: ['DE', 'FR', 'GB', 'IT', 'ES'] }
      ],
      variation: 'old-provider',
      percentage: 100
    }
  ],
  defaultVariation: 'old-provider'
};

Time-Based Targeting

Scheduled Feature Activation:

function evaluateTimeBasedFlag(flagConfig, currentTime) {
  const schedule = flagConfig.schedule;

  // Check if current time is within activation window
  if (schedule.startDate && currentTime < new Date(schedule.startDate)) {
    return false;
  }

  if (schedule.endDate && currentTime > new Date(schedule.endDate)) {
    return false;
  }

  // Check day of week restrictions
  if (schedule.daysOfWeek) {
    const currentDay = currentTime.getDay();
    if (!schedule.daysOfWeek.includes(currentDay)) {
      return false;
    }
  }

  // Check time of day restrictions
  if (schedule.timeRange) {
    const currentHour = currentTime.getHours();
    const startHour = schedule.timeRange.start;
    const endHour = schedule.timeRange.end;

    if (currentHour < startHour || currentHour >= endHour) {
      return false;
    }
  }

  return true;
}

// Example usage
const blackFridayFlag = {
  name: 'black-friday-deals',
  schedule: {
    startDate: '2024-11-29T00:00:00Z',
    endDate: '2024-12-02T23:59:59Z',
    daysOfWeek: [5, 6, 0], // Friday, Saturday, Sunday
    timeRange: { start: 0, end: 24 }
  }
};

Monitoring and Analytics

Feature Usage Metrics

Analytics Integration:

import { trackFeatureUsage } from './analytics';

class FeatureFlagAnalytics {
  constructor(analyticsClient) {
    this.analytics = analyticsClient;
    this.flagEvaluations = new Map();
  }

  trackEvaluation(flagKey, variation, user) {
    // Track flag evaluation
    this.analytics.track('Feature Flag Evaluated', {
      flag: flagKey,
      variation: variation,
      userId: user.id,
      timestamp: Date.now()
    });

    // Update evaluation counter
    const key = `${flagKey}:${variation}`;
    const count = this.flagEvaluations.get(key) || 0;
    this.flagEvaluations.set(key, count + 1);
  }

  trackConversion(flagKey, variation, user, eventType, value) {
    // Track feature conversion event
    this.analytics.track('Feature Conversion', {
      flag: flagKey,
      variation: variation,
      eventType: eventType,
      value: value,
      userId: user.id,
      timestamp: Date.now()
    });
  }

  getEvaluationStats() {
    const stats = {};
    for (const [key, count] of this.flagEvaluations) {
      const [flag, variation] = key.split(':');
      if (!stats[flag]) stats[flag] = {};
      stats[flag][variation] = count;
    }
    return stats;
  }
}

A/B Test Analytics

Statistical Analysis:

class ABTestAnalyzer {
  calculateSignificance(controlMetrics, variantMetrics) {
    // Calculate conversion rates
    const controlRate = controlMetrics.conversions / controlMetrics.impressions;
    const variantRate = variantMetrics.conversions / variantMetrics.impressions;

    // Calculate pooled standard error
    const pooledRate = (controlMetrics.conversions + variantMetrics.conversions) /
                       (controlMetrics.impressions + variantMetrics.impressions);

    const standardError = Math.sqrt(
      pooledRate * (1 - pooledRate) *
      (1 / controlMetrics.impressions + 1 / variantMetrics.impressions)
    );

    // Calculate z-score
    const zScore = (variantRate - controlRate) / standardError;

    // Calculate p-value (two-tailed test)
    const pValue = 2 * (1 - this.normalCDF(Math.abs(zScore)));

    // Calculate confidence interval
    const marginOfError = 1.96 * standardError;
    const lift = ((variantRate - controlRate) / controlRate) * 100;

    return {
      controlRate: (controlRate * 100).toFixed(2) + '%',
      variantRate: (variantRate * 100).toFixed(2) + '%',
      lift: lift.toFixed(2) + '%',
      pValue: pValue.toFixed(4),
      significant: pValue < 0.05,
      confidenceInterval: [
        ((variantRate - marginOfError) * 100).toFixed(2) + '%',
        ((variantRate + marginOfError) * 100).toFixed(2) + '%'
      ],
      sampleSize: {
        control: controlMetrics.impressions,
        variant: variantMetrics.impressions
      }
    };
  }

  normalCDF(x) {
    // Approximation of cumulative normal distribution
    const t = 1 / (1 + 0.2316419 * Math.abs(x));
    const d = 0.3989423 * Math.exp(-x * x / 2);
    const prob = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))));
    return x > 0 ? 1 - prob : prob;
  }
}

Real-Time Dashboard

Metrics Visualization:

// Feature flag dashboard metrics
const dashboardMetrics = {
  flags: [
    {
      key: 'new-checkout-flow',
      status: 'active',
      rollout: 45,
      evaluations: 125430,
      variations: {
        enabled: { count: 56444, percentage: 45 },
        disabled: { count: 68986, percentage: 55 }
      },
      metrics: {
        conversionRate: {
          enabled: 12.4,
          disabled: 10.8,
          lift: 14.8
        },
        errorRate: {
          enabled: 0.02,
          disabled: 0.03
        },
        avgResponseTime: {
          enabled: 245,
          disabled: 298
        }
      },
      lastModified: '2024-03-15T14:32:00Z',
      modifiedBy: 'john.doe@example.com'
    }
  ]
};

---

DevsForge Feature Flag Manager - Enterprise-grade feature management with progressive rollouts, A/B testing, and comprehensive analytics for data-driven product development.