Indicateurs de fonctionnalité

Les indicateurs de fonctionnalité vous permettent d’activer ou de désactiver à distance des fonctionnalités pour une sélection spécifique ou aléatoire d’utilisateurs. Point essentiel : ils vous permettent d’activer et de désactiver une fonctionnalité en production sans déploiement de code supplémentaire ni mise à jour sur les boutiques d’applications. Vous pouvez ainsi déployer de nouvelles fonctionnalités en toute sécurité et en toute confiance.

Conseil

Lorsque vous êtes prêt à créer vos propres indicateurs de fonctionnalité, consultez la rubrique Créer des indicateurs de fonctionnalité.

Prérequis

Voici les versions minimales du SDK nécessaires pour commencer à utiliser les indicateurs de fonctionnalité :

Cas d’usage

Déploiements progressifs

Utilisez les indicateurs de fonctionnalité pour activer progressivement des fonctionnalités auprès d’un échantillon de population. Par exemple, vous pouvez lancer en douceur une nouvelle fonctionnalité auprès de vos utilisateurs VIP en premier. Cette stratégie permet d’atténuer les risques liés au déploiement de nouvelles fonctionnalités auprès de tout le monde en même temps et de détecter les bugs plus tôt.

Par exemple, supposons que nous ayons décidé d’ajouter un nouveau lien « Assistance par chat en direct » dans notre application pour un service client plus rapide. Nous pourrions publier cette fonctionnalité à tous les clients en même temps. Cependant, un déploiement large comporte des risques, tels que :

• Notre équipe d’assistance est encore en formation, et les clients pourront ouvrir des tickets d’assistance dès la publication. Cela ne nous laisse aucune marge si l’équipe d’assistance a besoin de plus de temps.
• Nous ne connaissons pas le volume réel de nouveaux cas d’assistance que nous recevrons, et nos effectifs pourraient ne pas être adaptés.
• Si notre équipe d’assistance est débordée, nous n’avons aucune stratégie pour désactiver rapidement cette fonctionnalité.
• Il pourrait y avoir des bugs dans le widget de chat, et nous ne voulons pas que les clients aient une expérience négative.

Avec les indicateurs de fonctionnalité de Braze, nous pouvons plutôt déployer progressivement la fonctionnalité et atténuer tous ces risques :

• Nous activerons la fonctionnalité « Assistance par chat en direct » lorsque l’équipe d’assistance indiquera qu’elle est prête.
• Nous n’activerons cette nouvelle fonctionnalité que pour 10 % des utilisateurs afin de déterminer si nos effectifs sont adaptés.
• S’il y a des bugs, nous pouvons rapidement désactiver la fonctionnalité au lieu de nous précipiter pour publier une nouvelle version.

Pour déployer progressivement cette fonctionnalité, nous pouvons créer un indicateur de fonctionnalité nommé « Live Chat Widget ».

Dans le code de notre application, nous n’afficherons le bouton Start Live Chat que lorsque l’indicateur de fonctionnalité Braze est activé :

• javascript
• java
• kotlin
• swift

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

import {useState} from "react";
import * as braze from "@braze/web-sdk";

// Get the initial value from the Braze SDK
const featureFlag = braze.getFeatureFlag("enable_live_chat");
const [liveChatEnabled, setLiveChatEnabled] = useState(featureFlag.enabled);

// Listen for updates from the Braze SDK
braze.subscribeToFeatureFlagsUpdates(() => {
    const newValue = braze.getFeatureFlag("enable_live_chat").enabled;
    setLiveChatEnabled(newValue);
});

// Only show the Live Chat if the Braze SDK determines it is enabled
return (<>
  Need help? <button>Email Our Team</button>
  {liveChatEnabled && <button>Start Live Chat</button>}
</>)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// Get the initial value from the Braze SDK
FeatureFlag featureFlag = braze.getFeatureFlag("enable_live_chat");
Boolean liveChatEnabled = featureFlag != null && featureFlag.getEnabled();

// Listen for updates from the Braze SDK
braze.subscribeToFeatureFlagsUpdates(event -> {
  FeatureFlag newFeatureFlag = braze.getFeatureFlag("enable_live_chat");
  Boolean newValue = newFeatureFlag != null && newFeatureFlag.getEnabled();
  liveChatEnabled = newValue;
});

// Only show the Live Chat view if the Braze SDK determines it is enabled
if (liveChatEnabled) {
  liveChatView.setVisibility(View.VISIBLE);
} else {
  liveChatView.setVisibility(View.GONE);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// Get the initial value from the Braze SDK
val featureFlag = braze.getFeatureFlag("enable_live_chat")
var liveChatEnabled = featureFlag?.enabled

// Listen for updates from the Braze SDK
braze.subscribeToFeatureFlagsUpdates() { event ->
  val newValue = braze.getFeatureFlag("enable_live_chat")?.enabled
  liveChatEnabled = newValue
}

// Only show the Live Chat view if the Braze SDK determines it is enabled
if (liveChatEnabled) {
  liveChatView.visibility = View.VISIBLE
} else {
  liveChatView.visibility = View.GONE
}

Remarque

La lecture de braze.featureFlags.featureFlags ou braze.featureFlags.featureFlag(id:) bloque le thread appelant jusqu’à ce que le SDK ait terminé ses opérations post-initialisation. Pour les contextes liés au thread principal ou sensibles à la latence, utilisez getAllFeatureFlags(_:) à la place.

1
2
3
4
5

// Non-blocking — completion handler always delivers on the main thread.
braze.featureFlags.getAllFeatureFlags { flags in
  let liveChatEnabled = flags.first(where: { $0.id == "enable_live_chat" })?.enabled ?? false
  liveChatView.isHidden = !liveChatEnabled
}

En Objective-C :

1
2
3

[braze.featureFlags getAllFeatureFlagsWithCompletion:^(NSArray<BRZFeatureFlag *> *flags) {
  // Use `flags` here.
}];

1
2
3
4
5
6
7
8
9
10
11
12

// Get the initial value from the Braze SDK
let featureFlag = braze.featureFlags.featureFlag(id: "enable_live_chat")
var liveChatEnabled = featureFlag?.enabled ?? false

// Listen for updates from the Braze SDK
braze.featureFlags.subscribeToUpdates() { _ in
  let newValue = braze.featureFlags.featureFlag(id: "enable_live_chat")?.enabled ?? false
  liveChatEnabled = newValue
}

// Only show the Live Chat view if the Braze SDK determines it is enabled
liveChatView.isHidden = !liveChatEnabled

Contrôle à distance des variables de l’application

Utilisez les indicateurs de fonctionnalité pour modifier le fonctionnement de votre application en production. Cela peut être particulièrement important pour les applications mobiles, où les validations des boutiques d’applications empêchent de déployer rapidement des changements à tous les utilisateurs.

Par exemple, supposons que notre équipe marketing souhaite lister nos ventes et promotions actuelles dans la navigation de notre application. Normalement, nos ingénieurs ont besoin d’une semaine de préparation pour tout changement et de trois jours pour la validation par la boutique d’applications. Mais avec Thanksgiving, le Black Friday, le Cyber Monday, Hanoukka, Noël et le Nouvel An, le tout en l’espace de deux mois, nous ne pourrons pas tenir ces délais serrés.

Avec les indicateurs de fonctionnalité, nous pouvons laisser Braze piloter le contenu du lien de navigation de notre application, permettant à notre responsable marketing d’effectuer des changements en quelques minutes plutôt qu’en plusieurs jours.

Pour configurer cette fonctionnalité à distance, nous allons créer un nouvel indicateur de fonctionnalité appelé navigation_promo_link et définir les propriétés initiales suivantes :

Dans notre application, nous utiliserons les méthodes getter de Braze pour récupérer les propriétés de cet indicateur de fonctionnalité et créer les liens de navigation à partir de ces valeurs :

• javascript
• java
• kotlin
• swift

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import * as braze from "@braze/web-sdk";
import {useState} from "react";

const featureFlag = braze.getFeatureFlag("navigation_promo_link");
// Check if the feature flag is enabled
const [promoEnabled, setPromoEnabled] = useState(featureFlag.enabled);
// Read the "link" property
const [promoLink, setPromoLink] = useState(featureFlag.getStringProperty("link"));
// Read the "text" property
const [promoText, setPromoText] = useState(featureFlag.getStringProperty("text"));

return (<>
  <div>
    <a href="/">Home</a>
    { promoEnabled && <a href={promoLink}>{promoText}</a> }
    <a href="/products">Products</a>
    <a href="/categories">Categories
  </div>
</>)

1
2
3
4
5
6
7
8
9
10

// liveChatView is the View container for the Live Chat UI
FeatureFlag featureFlag = braze.getFeatureFlag("navigation_promo_link");
if (featureFlag != null && featureFlag.getEnabled()) {
  liveChatView.setVisibility(View.VISIBLE);
} else {
  liveChatView.setVisibility(View.GONE);
}
liveChatView.setPromoLink(featureFlag.getStringProperty("link"));
liveChatView.setPromoText(featureFlag.getStringProperty("text"));

1
2
3
4
5
6
7
8
9

// liveChatView is the View container for the Live Chat UI
val featureFlag = braze.getFeatureFlag("navigation_promo_link")
if (featureFlag?.enabled == true) {
  liveChatView.visibility = View.VISIBLE
} else {
  liveChatView.visibility = View.GONE
}
liveChatView.promoLink = featureFlag?.getStringProperty("link")
liveChatView.promoText = featureFlag?.getStringProperty("text")

1
2
3
4
5
6
7
8

let featureFlag = braze.featureFlags.featureFlag(id: "navigation_promo_link")
if let featureFlag {
  liveChatView.isHidden = !featureFlag.enabled
} else {
  liveChatView.isHidden = true
}
liveChatView.promoLink = featureFlag?.stringProperty("link")
liveChatView.promoText = featureFlag?.stringProperty("text")

Désormais, la veille de Thanksgiving, il nous suffit de modifier les valeurs des propriétés dans le tableau de bord de Braze.

En conséquence, la prochaine fois qu’un utilisateur chargera l’application, il verra les nouvelles offres de Thanksgiving.

Coordination des messages

Utilisez les indicateurs de fonctionnalité pour synchroniser le déploiement d’une fonctionnalité et la communication associée, et renforcer la collaboration entre les équipes produit et marketing. En coordonnant les déploiements de fonctionnalités et la communication via les indicateurs de fonctionnalité, les deux équipes peuvent aligner leurs stratégies et créer des expériences utilisateur cohérentes.

Par exemple, supposons que nous lançons un nouveau programme de fidélité pour nos utilisateurs. Il peut être difficile pour les équipes marketing et produit de coordonner parfaitement le timing des messages promotionnels avec le déploiement d’une fonctionnalité. Cependant, grâce aux indicateurs de fonctionnalité dans Canvas, notre équipe produit peut appliquer une logique sophistiquée pour activer une fonctionnalité auprès d’une audience spécifique, tandis que notre équipe marketing gère les messages associés à ces mêmes utilisateurs.

Pour coordonner efficacement le déploiement de la fonctionnalité et la communication, nous allons créer un nouvel indicateur de fonctionnalité appelé show_loyalty_program. Pour notre déploiement initial par phases, nous laisserons Canvas contrôler quand et pour qui l’indicateur de fonctionnalité est activé. Pour l’instant, nous laisserons le pourcentage de déploiement à 0 % et ne sélectionnerons aucun Segment cible.

Ensuite, dans Canvas, nous créerons une étape Indicateur de fonctionnalité qui active l’indicateur de fonctionnalité show_loyalty_program pour notre Segment « Clients à haute valeur » :

Désormais, les utilisateurs de ce Segment commencent à voir le nouveau programme de fidélité, et une fois celui-ci activé, un e-mail et un sondage sont envoyés automatiquement pour aider nos équipes à recueillir des retours.

Expérimentation de fonctionnalités

Utilisez les indicateurs de fonctionnalité pour expérimenter et confirmer vos hypothèses autour de votre nouvelle fonctionnalité. En divisant le trafic en deux groupes ou plus, vous pouvez comparer l’impact d’un indicateur de fonctionnalité entre les groupes et déterminer la meilleure ligne de conduite en fonction des résultats.

Pour les expérimentations d’indicateurs de fonctionnalité, vous pouvez avoir jusqu’à neuf groupes au total : un groupe de contrôle plus jusqu’à huit variantes.

Un test A/B est un outil puissant qui compare les réponses des utilisateurs à plusieurs versions d’une variable.

Dans cet exemple, notre équipe a créé un nouveau flux de paiement pour notre application e-commerce. Même si nous sommes convaincus qu’il améliore l’expérience utilisateur, nous voulons effectuer un test A/B pour mesurer son impact sur le chiffre d’affaires de notre application.

Pour commencer, nous allons créer un nouvel indicateur de fonctionnalité appelé enable_checkout_v2. Nous n’ajouterons pas d’audience ni de pourcentage de déploiement. Au lieu de cela, nous utiliserons une expérimentation d’indicateur de fonctionnalité pour diviser le trafic, activer la fonctionnalité et mesurer les résultats.

Dans notre application, nous vérifierons si l’indicateur de fonctionnalité est activé ou non et échangerons le flux de paiement en fonction de la réponse :

• javascript
• java
• kotlin
• swift

1
2
3
4
5
6
7
8
9

import * as braze from "@braze/web-sdk";

const featureFlag = braze.getFeatureFlag("enable_checkout_v2");
braze.logFeatureFlagImpression("enable_checkout_v2");
if (featureFlag?.enabled) {
  return <NewCheckoutFlow />
} else {
  return <OldCheckoutFlow />
}

1
2
3
4
5
6
7

FeatureFlag featureFlag = braze.getFeatureFlag("enable_checkout_v2");
braze.logFeatureFlagImpression("enable_checkout_v2");
if (featureFlag != null && featureFlag.getEnabled()) {
  return new NewCheckoutFlow();
} else {
  return new OldCheckoutFlow();
}

1
2
3
4
5
6
7

val featureFlag = braze.getFeatureFlag("enable_checkout_v2")
braze.logFeatureFlagImpression("enable_checkout_v2")
if (featureFlag?.enabled == true) {
  return NewCheckoutFlow()
} else {
  return OldCheckoutFlow()
}

1
2
3
4
5
6
7

let featureFlag = braze.featureFlags.featureFlag(id: "enable_checkout_v2")
braze.featureFlags.logFeatureFlagImpression(id: "enable_checkout_v2")
if let featureFlag, featureFlag.enabled {
  return NewCheckoutFlow()
} else {
  return OldCheckoutFlow()
}

Nous allons configurer notre test A/B dans une expérimentation d’indicateur de fonctionnalité.

Désormais, 50 % des utilisateurs verront l’ancienne expérience, tandis que les 50 % restants verront la nouvelle expérience. Nous pourrons ensuite analyser les deux variantes pour déterminer quel flux de paiement a généré le taux de conversion le plus élevé.

Le taux de conversion est le pourcentage de fois où un événement défini s’est produit par rapport à l’ensemble des destinataires d’un message. Cet événement défini est déterminé lors de la création de la campagne.

Une fois que nous avons déterminé le gagnant, nous pouvons arrêter cette Campaign et augmenter le pourcentage de déploiement de l’indicateur de fonctionnalité à 100 % pour tous les utilisateurs, pendant que notre équipe d’ingénierie l’intègre en dur dans la prochaine version de l’application.

Segmentation

Utilisez le filtre Indicateur de fonctionnalité pour créer un Segment ou cibler des messages auprès d’utilisateurs en fonction de l’activation ou non d’un indicateur de fonctionnalité. Par exemple, supposons que vous ayez un indicateur de fonctionnalité qui contrôle le contenu premium de votre application. Vous pourriez créer un Segment qui filtre les utilisateurs pour lesquels l’indicateur de fonctionnalité n’est pas activé, puis envoyer à ce Segment un message les encourageant à mettre à niveau leur compte pour accéder au contenu premium.

1. Ouvrez votre Segment ou l’audience de votre message.
2. Ajoutez le filtre Indicateur de fonctionnalité.
3. Sélectionnez l’indicateur de fonctionnalité.
4. Définissez le comparateur sur est pour inclure les utilisateurs ayant l’indicateur de fonctionnalité activé, ou n’est pas pour inclure les utilisateurs qui ne l’ont pas.

Pour plus d’informations sur le filtrage des Segments, consultez Créer un Segment.

Remarque

Pour éviter les Segments récursifs, il n’est pas possible de créer un Segment qui fait référence à d’autres indicateurs de fonctionnalité.

Limites des plans

Voici les limites des indicateurs de fonctionnalité pour les plans gratuits et payants.

Un indicateur de fonctionnalité est considéré comme actif et sera comptabilisé dans votre limite si l’une des conditions suivantes s’applique :

• Le déploiement est supérieur à 0 %
• Utilisé dans un Canvas actif
• Utilisé dans une expérience active

Même si le même indicateur de fonctionnalité correspond à plusieurs critères, par exemple s’il est utilisé dans un Canvas et que le déploiement est de 50 %, il ne comptera que comme 1 indicateur de fonctionnalité actif dans votre limite.

Remarque

Pour acheter la version payante des indicateurs de fonctionnalité, contactez votre gestionnaire de compte Braze ou demandez une mise à niveau dans le tableau de bord de Braze.