How to Use Channels for Feature Flags and A/B Testing

CapGo’s channel system provides a flexible way to segment users and control feature access. While CapGo doesn’t have built-in plan management or A/B testing, you can implement these features by managing channel assignments yourself.

Understanding Channels

Channels in CapGo allow you to:

• Target specific user groups with different features
• Run A/B tests by assigning users to different channels
• Gradually roll out new features
• Create beta testing programs

Channel Assignment Methods

1. Backend Assignment (Recommended)

This is the more secure method. It involves:

1. Getting the device ID from the updater
2. Sending it to your backend
3. Your backend calls the CapGo API to assign the device

Here’s how to implement it:

import { CapacitorUpdater } from '@capgo/capacitor-updater'

// Get device ID
const getDeviceId = async () => {
  const { deviceId } = await CapacitorUpdater.getDeviceId()
  return deviceId
}

// Send device ID to your backend
const assignToChannel = async (channel: string) => {
  const deviceId = await getDeviceId()
  // Your backend will call CapGo API to assign the device
  await yourBackend.assignDeviceToChannel(deviceId, channel)
}

Backend Implementation

Your backend needs to:

1. Get an API key from CapGo dashboard
2. Call the CapGo API to assign the device to a channel

To get your API key:

1. Log in to your CapGo dashboard
2. Go to Settings > API Keys
3. Click “Generate New Key”
4. Select all mode to manage devices and channels
5. Copy the generated key and store it securely in your backend environment variables
   • The key will be a 32-character hexadecimal string
   • It’s a secret key that should never be exposed in client-side code

Here’s a Node.js example:

import axios from 'axios'

const CAPGO_API_KEY = 'your_api_key'
const CAPGO_API_URL = 'https://api.capgo.app'

async function assignDeviceToChannel(deviceId: string, channel: string) {
  try {
    const response = await axios.post(
      `${CAPGO_API_URL}/device`,
      {
        app_id: 'YOUR_APP_ID',
        device_id: deviceId,
        channel: channel
      },
      {
        headers: {
          'authorization': CAPGO_API_KEY,
          'Content-Type': 'application/json'
        }
      }
    )
    return response.data
  } catch (error) {
    console.error('Failed to assign device to channel:', error)
    throw error
  }
}

The backend should also:

• Validate the user’s permissions
• Log all channel assignments
• Handle rate limiting
• Implement retry logic for failed assignments

2. Self-Assignment (Less Secure)

This method allows devices to directly assign themselves to a channel. It’s useful for testing but less secure for production:

import { CapacitorUpdater } from '@capgo/capacitor-updater'

// Assign device to channel
const assignToChannel = async (channel: string) => {
  await CapacitorUpdater.setChannel(channel)
}

// Get current channel
const getCurrentChannel = async () => {
  const { channel } = await CapacitorUpdater.getChannel()
  return channel
}

Before users can self-assign to a channel, you need to enable this feature in the CapGo dashboard:

1. Go to the Channels section in your CapGo dashboard
2. Click on the channel name you want to manage
3. In the channel settings, enable “Allow devices to self associate”
4. Save the changes

If this setting is false, any attempt to call setChannel with this channel will fail.

Implementing Feature Flags

Use channels to control feature access:

const isFeatureEnabled = async (feature: string) => {
  // Example: Check if user is in beta channel
  const channel = await getCurrentChannel()
  return channel === 'beta'
}

A/B Testing Implementation

Run A/B tests by assigning users to different channels:

const assignToABTest = async (userId: string) => {
  // Use consistent hashing to assign users
  const hash = await hashUserId(userId)
  const variant = hash % 2 === 0 ? 'variant-a' : 'variant-b'

  await assignToChannel(variant)
  return variant
}

Best Practices

1. Use Backend Assignment: For production, always use the backend assignment method
2. Consistent Assignment: Use user IDs or other stable identifiers for consistent channel assignment
3. Monitoring: Track feature usage and performance metrics for each channel
4. Gradual Rollouts: Start with small user segments and gradually expand
5. Clear Documentation: Document your channel strategy and purposes

Conclusion

By leveraging CapGo’s channel system, you can create more personalized app experiences and run A/B tests. For production use, always prefer the backend assignment method for better security and control.

For more details on channel management, check out our channels documentation.