Feature-Flags

Feature-Flags ermöglichen es Ihnen, Funktionen für eine bestimmte oder zufällige Auswahl von Nutzer:innen aus der Ferne zu aktivieren oder zu deaktivieren. Wichtig ist, dass Sie damit ein Feature in der Produktion ein- und ausschalten können, ohne zusätzlichen Code zu implementieren oder Updates im App Store durchzuführen. Dies erlaubt es Ihnen, neue Features sicher und zuverlässig einzuführen.

Tipp

Wenn Sie bereit sind, Ihre eigenen Feature-Flags zu erstellen, lesen Sie den Abschnitt Feature-Flags erstellen.

Voraussetzungen

Dies sind die Mindest-SDK-Versionen, die für die Verwendung von Feature-Flags erforderlich sind:

Anwendungsfälle

Schrittweise Rollouts

Verwenden Sie Feature-Flags, um Features schrittweise für eine Stichprobe der Nutzer:innen zu aktivieren. Zum Beispiel können Sie ein neues Feature zunächst nur für Ihre VIP-Nutzer:innen per Soft-Launch veröffentlichen. Diese Strategie hilft, Risiken zu minimieren, die mit der gleichzeitigen Veröffentlichung neuer Features für alle verbunden sind, und hilft, Fehler frühzeitig zu erkennen.

Nehmen wir beispielsweise an, wir haben beschlossen, einen neuen Link „Live Chat Support“ zu unserer App hinzuzufügen, um einen schnelleren Kundenservice zu ermöglichen. Wir könnten dieses Feature sofort für alle Kund:innen freigeben. Ein breiter Release birgt jedoch Risiken, wie zum Beispiel:

• Unser Support-Team befindet sich noch in der Schulung, und Kund:innen können Support-Tickets erstellen, sobald das Feature veröffentlicht ist. Das gibt uns keinen Spielraum, falls das Support-Team mehr Zeit benötigt.
• Wir sind uns über das tatsächliche Volumen neuer Support-Anfragen unsicher und haben möglicherweise nicht ausreichend Personal.
• Wenn unser Support-Team überlastet ist, haben wir keine Strategie, dieses Feature schnell wieder zu deaktivieren.
• Es könnten Fehler im Chat-Widget auftreten, und wir möchten nicht, dass Kund:innen eine negative Erfahrung machen.

Mit Braze Feature-Flags können wir stattdessen das Feature schrittweise ausrollen und all diese Risiken minimieren:

• Wir aktivieren das Feature „Live Chat Support“, wenn das Support-Team meldet, dass es bereit ist.
• Wir aktivieren dieses neue Feature nur für 10 % der Nutzer:innen, um festzustellen, ob wir angemessen besetzt sind.
• Sollte es Fehler geben, können wir das Feature schnell deaktivieren, anstatt eilig einen neuen Release ausliefern zu müssen.

Um dieses Feature schrittweise auszurollen, können wir ein Feature-Flag erstellen mit dem Namen „Live Chat Widget“.

In unserem App-Code zeigen wir den Button Start Live Chat nur dann an, wenn das Braze Feature-Flag aktiviert ist:

• 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
}

Hinweis

Das Lesen von braze.featureFlags.featureFlags oder braze.featureFlags.featureFlag(id:) blockiert den aufrufenden Thread, bis das SDK seine Post-Initialisierungsvorgänge abgeschlossen hat. Verwenden Sie für Main-Thread- oder latenzempfindliche Kontexte stattdessen getAllFeatureFlags(_:).

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
}

In 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

App-Variablen per Fernzugriff steuern

Verwenden Sie Feature-Flags, um die Funktionalität Ihrer App in der Produktion zu ändern. Dies kann besonders für mobile Apps wichtig sein, bei denen App-Store-Genehmigungen das schnelle Ausrollen von Änderungen für alle Nutzer:innen verhindern.

Nehmen wir beispielsweise an, unser Marketing-Team möchte unsere aktuellen Angebote und Aktionen in der Navigation unserer App auflisten. Normalerweise benötigen unsere Entwickler:innen eine Woche Vorlaufzeit für alle Änderungen und drei Tage für eine App-Store-Prüfung. Aber mit Thanksgiving, Black Friday, Cyber Monday, Chanukka, Weihnachten und Neujahr – alles innerhalb von zwei Monaten – werden wir diese engen Fristen nicht einhalten können.

Mit Feature-Flags können wir Braze den Inhalt unseres App-Navigationslinks steuern lassen, sodass unser:e Marketing-Manager:in Änderungen in Minuten statt in Tagen vornehmen kann.

Um dieses Feature per Fernzugriff zu konfigurieren, erstellen wir ein neues Feature-Flag namens navigation_promo_link und definieren die folgenden initialen Eigenschaften:

In unserer App verwenden wir Getter-Methoden von Braze, um die Eigenschaften dieses Feature-Flags abzurufen und die Navigationslinks basierend auf diesen Werten zu erstellen:

• 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")

Am Tag vor Thanksgiving müssen wir nun lediglich diese Eigenschaftswerte im Braze-Dashboard ändern.

Wenn nun das nächste Mal jemand die App lädt, sieht er die neuen Thanksgiving-Angebote.

Nachrichtenkoordination

Verwenden Sie Feature-Flags, um den Rollout eines Features und das zugehörige Messaging zu synchronisieren und die Zusammenarbeit zwischen Produkt- und Marketing-Teams zu stärken. Durch die Koordination von Feature-Releases und Messaging über Feature-Flags können beide Teams ihre Strategien abstimmen und konsistente Nutzer:innenerlebnisse schaffen.

Nehmen wir beispielsweise an, dass wir ein neues Kundenbindungs-Rewards-Programm für unsere Nutzer:innen einführen. Es kann schwierig sein, den Zeitpunkt der Werbenachrichten mit dem Rollout eines Features perfekt zwischen Marketing- und Produkt-Teams zu koordinieren. Mit Feature-Flags in Canvas kann unser Produkt-Team jedoch ausgefeilte Logik anwenden, um ein Feature für eine bestimmte Zielgruppe zu aktivieren, während unser Marketing-Team das zugehörige Messaging an dieselben Nutzer:innen steuert.

Um den Feature-Rollout und das Messaging effektiv zu koordinieren, erstellen wir ein neues Feature-Flag namens show_loyalty_program. Für unseren anfänglichen stufenweisen Release lassen wir Canvas steuern, wann und für wen das Feature-Flag aktiviert wird. Vorerst belassen wir den Rollout-Prozentsatz bei 0 % und wählen keine Zielsegmente aus.

Dann erstellen wir in Canvas einen Feature-Flag-Schritt, der das Feature-Flag show_loyalty_program für unser Segment „High Value Customers“ aktiviert:

Jetzt sehen Nutzer:innen in diesem Segment das neue Kundenbindungsprogramm, und nachdem es aktiviert wurde, werden automatisch eine E-Mail und eine Umfrage versendet, um unserem Team zu helfen, Feedback zu sammeln.

Feature-Experimente

Verwenden Sie Feature-Flags, um Ihre Hypothesen rund um ein neues Feature zu experimentieren und zu bestätigen. Indem Sie den Traffic in zwei oder mehr Gruppen aufteilen, können Sie die Auswirkungen eines Feature-Flags über die Gruppen hinweg vergleichen und die beste Vorgehensweise anhand der Ergebnisse bestimmen.

Für Feature-Flag-Experimente können Sie insgesamt bis zu neun Gruppen haben: eine Kontrollgruppe plus bis zu acht Varianten.

Ein A/B-Test ist ein leistungsstarkes Instrument, das die Reaktionen der Nutzer:innen auf mehrere Versionen einer Variable vergleicht.

In diesem Beispiel hat unser Team einen neuen Checkout-Flow für unsere E-Commerce-App entwickelt. Obwohl wir zuversichtlich sind, dass er die Nutzer:innenerfahrung verbessert, möchten wir einen A/B-Test durchführen, um die Auswirkungen auf den Umsatz unserer App zu messen.

Zunächst erstellen wir ein neues Feature-Flag namens enable_checkout_v2. Wir fügen keine Zielgruppe oder einen Rollout-Prozentsatz hinzu. Stattdessen verwenden wir ein Feature-Flag-Experiment, um den Traffic aufzuteilen, das Feature zu aktivieren und das Ergebnis zu messen.

In unserer App prüfen wir, ob das Feature-Flag aktiviert ist oder nicht, und tauschen den Checkout-Flow entsprechend aus:

• 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()
}

Wir richten unseren A/B-Test in einem Feature-Flag-Experiment ein.

Nun sehen 50 % der Nutzer:innen die alte Version, während die anderen 50 % die neue Version sehen. Anschließend können wir die beiden Varianten analysieren, um festzustellen, welcher Checkout-Flow zu einer höheren Konversionsrate geführt hat.

Die Konversionsrate ist der Prozentsatz der Häufigkeit, mit der ein definiertes Ereignis im Vergleich zu allen Empfänger:innen einer Nachricht eingetreten ist. Dieses definierte Ereignis wird festgelegt, wenn Sie die Campaign erstellen.

Sobald wir den Gewinner ermittelt haben, können wir diese Campaign stoppen und den Rollout-Prozentsatz des Feature-Flags für alle Nutzer:innen auf 100 % erhöhen, während unser Entwicklerteam dies fest in unseren nächsten App-Release einbaut.

Segmentierung

Verwenden Sie den Filter Feature-Flag, um ein Segment zu erstellen oder Messaging an Nutzer:innen zu richten, basierend darauf, ob sie ein Feature-Flag aktiviert haben. Nehmen wir beispielsweise an, Sie haben ein Feature-Flag, das Premium-Inhalte in Ihrer App steuert. Sie könnten ein Segment erstellen, das nach Nutzer:innen filtert, bei denen das Feature-Flag nicht aktiviert ist, und diesem Segment dann eine Nachricht senden, die sie auffordert, ihr Konto zu upgraden, um Premium-Inhalte anzuzeigen.

1. Öffnen Sie Ihr Segment oder Ihre Nachrichtenzielgruppe.
2. Fügen Sie den Filter Feature-Flag hinzu.
3. Wählen Sie das Feature-Flag aus.
4. Setzen Sie den Vergleichsoperator auf ist, um Nutzer:innen einzuschließen, bei denen das Feature-Flag aktiviert ist, oder auf ist nicht, um Nutzer:innen einzuschließen, bei denen es nicht aktiviert ist.

Weitere Informationen zum Filtern nach Segmenten finden Sie unter Ein Segment erstellen.

Hinweis

Um rekursive Segmente zu verhindern, ist es nicht möglich, ein Segment zu erstellen, das auf andere Feature-Flags verweist.

Einschränkungen nach Tarif

Dies sind die Feature-Flag-Einschränkungen für kostenlose und kostenpflichtige Tarife.

Ein Feature-Flag gilt als aktiv und wird auf Ihr Limit angerechnet, wenn eine der folgenden Bedingungen zutrifft:

• Der Rollout beträgt mehr als 0 %
• Wird in einem aktiven Canvas verwendet
• Wird in einem aktiven Experiment verwendet

Auch wenn dasselbe Feature-Flag mehrere Kriterien erfüllt, z. B. wenn es in einem Canvas verwendet wird und der Rollout bei 50 % liegt, zählt es nur als 1 aktives Feature-Flag für Ihr Limit.

Hinweis

Um die kostenpflichtige Version von Feature-Flags zu erwerben, wenden Sie sich an Ihren Braze Account Manager oder fordern Sie ein Upgrade im Braze-Dashboard an.