Signal : une plateforme de feature flags TypeScript-first conçue pour la production

Le problème avec les outils existants

Les feature flags sont conceptuellement simples. En pratique, la plupart des plateformes les rendent pénibles à opérer à l'échelle.

Les modes de défaillance les plus courants :

• Latence d'évaluation sur le chemin critique. L'évaluation côté serveur implique un appel réseau par vérification de flag. Même mis en cache, cela ajoute de la latence à chaque requête.
• Aucune type safety. Les clés de flags sont parsemées dans le code sous forme de chaînes brutes. Une faute de frappe tombe silencieusement sur la valeur par défaut. Les refactorings deviennent risqués.
• Types de flags grossiers. Beaucoup de plateformes ne gèrent que les booléens. Les variantes, seuils et configurations JSON finissent par être des systèmes séparés greffés après coup.
• Le temps réel en option. Un polling toutes les 30 secondes signifie que les changements de flags mettent jusqu'à 30 secondes à se propager. En incident, ça compte.

Signal a été conçu pour répondre à ces quatre problèmes.

Évaluation locale avec zéro latence

Le SDK serveur de Signal télécharge le jeu de règles complet au démarrage et évalue localement. Les vérifications de flags sont synchrones — pas d'appel réseau sur le chemin critique.

const signal = getServerInstance();
 
// Synchrone — pas d'await, pas de réseau, sous la milliseconde
const enabled = signal.isEnabledSync('checkout-v2', { userId: req.user.id });

Le jeu de règles est maintenu synchronisé via WebSocket. Quand un flag change dans le dashboard, chaque instance SDK connectée reçoit un événement FLAG_UPDATED et met à jour son cache local en moins de 50ms.

Vous obtenez ainsi le contrôle de la gestion côté serveur avec la performance de l'évaluation en processus.

Clés de flags typées

Les clés de flags dans Signal sont des constantes typées, pas des chaînes brutes. Définissez-les une fois :

import { createFeatureFlag } from '@code-signal/signal';
 
export const FLAGS = {
  CHECKOUT_V2: createFeatureFlag('checkout-v2'),
  DARK_MODE:   createFeatureFlag('dark-mode'),
  MAX_ITEMS:   createFeatureFlag('max-items'),
} as const;

Votre IDE les autocomplétera. TypeScript détectera les fautes de frappe à la compilation. Renommer un flag est un refactoring sûr.

Quatre types de valeurs

Signal supporte quatre types de valeurs de flags, tous avec le même moteur de ciblage et de déploiement progressif :

// Booléen
const enabled = await signal.isEnabled(FLAGS.CHECKOUT_V2, ctx);
 
// Variante string
const theme = await signal.getStringValue(FLAGS.UI_THEME, 'default', ctx);
 
// Seuil numérique
const limit = await signal.getNumberValue(FLAGS.MAX_ITEMS, 10, ctx);
 
// Configuration JSON
const config = await signal.getJsonValue(FLAGS.GRID_CONFIG, defaultConfig, ctx);

Bucketing déterministe

Les déploiements progressifs utilisent un bucketing déterministe par hash :

bucket = hash(userId + flagKey) % 100
enabled = bucket < rolloutPercentage

Avec le même ID utilisateur et la même clé de flag, le résultat est toujours identique — quelle que soit l'instance SDK qui traite la requête, le serveur qui la gère, ou le nombre de rechargements de page. Pas de sessions, pas de cookies, pas de routage sticky requis.

Un utilisateur dans les 10% reste dans les 10% quand vous montez le déploiement à 50%, puis 100%.

Support OpenFeature

Signal embarque des providers OpenFeature nativement :

import { OpenFeature } from '@openfeature/server-sdk';
import { SignalServerProvider } from '@code-signal/signal';
 
await OpenFeature.setProviderAndWait(new SignalServerProvider(config));
 
const client = OpenFeature.getClient();
const enabled = await client.getBooleanValue('checkout-v2', false, { targetingKey: userId });

Si vous utilisez déjà OpenFeature, Signal est un backend drop-in sans modification du code applicatif.

Bindings React

Pour les applications client, Signal embarque des hooks React qui s'abonnent aux mises à jour de flags en temps réel :

import { useFeatureFlag } from '@code-signal/signal';
 
function CheckoutButton() {
  const { enabled, loading } = useFeatureFlag('checkout-v2');
 
  if (loading) return <Skeleton />;
  return enabled ? <NewCheckout /> : <LegacyCheckout />;
}

Le hook se re-render automatiquement quand le flag change — pas de polling, pas de rechargement de page.

Bêta privée

Signal est en bêta privée. Nous travaillons étroitement avec les premiers utilisateurs pour valider la plateforme avant la disponibilité générale.

Rejoignez la liste d'attente pour un accès anticipé, un tarif garanti, et un accès direct à l'équipe d'ingénierie.