Changelog

We’ve shipped the Bucket toolbar. As a developer or product manager, it’s useful to toggle features on and off for yourself when testing your own (or team members) features.

The toolbar is built into our browser SDKs and will automatically appear when you visit “localhost” if the Bucket Browser SDK or Bucket React SDK is installed in the website.

For many, it makes sense to enable it in production for internal use. Setting “toolbar” to true will make the toolbar appear:

function App() {
  const user = useAuth();

  return (
    <BucketProvider toolbar={user?.isAdmin}>
      <Routes>
    </BucketProvider>
  )
}

Happy shipping!

We have shipped a command line interface (CLI) that you can use to interact with Bucket. The CLI removes any friction in creating features from the command line and helps you maintain type safety for your features:

› npm i @bucketco/cli --save-dev 
› bucket new "My Feature"

When creating a new feature, the CLI will automatically update your local types to make sure they match those defined in Bucket, saving you from making frustrating typos referencing your feature keys.

The CLI will also generate types for Remote Config based on the payloads configured in Bucket. This helps ensure that the shape of the payload you’ve configured in Bucket matches what you’re working with in the code.

function MyFeature() {

  // The feature key argument passed to the useFeature hook is strongly
  // typed and will give a compile-time error if the key does not exist.
  const { isEnabled, config } = useFeature("my-feature");

  if (!isEnabled) return null;

  // Given the following payload configured in Bucket:
  // {
  //   fontWeight: "bold",
  //   copy: "Sync now!"
  // }
  //
  // The CLI will generate the type:
  // {
  //   fontWeight: string;
  //   copy: string;
  // }
  //
  // Which will give a compile-time error when we refer to
  // the missing "fontBold" property below.
  return (
    <button style={{fontWeight: config.payload.fontBold}}>
      {config.payload.copy}
    </button>
  )
}

Happy shipping!

Sometimes you need to give a bunch of people access to features at once. Maybe you are migrating to Bucket from another feature flagging provider and need to transfer a list of beta users. Or someone from Customer Success hands you a CSV file with people who’ve opted into your beta program through email.

Now you just hit “Add in bulk” and paste in your list of IDs.

Note: “Add in bulk” is available to customers on the Pro and Enterprise plans.

We’ve made it possible to easily integrate Bucket with other systems through event listeners in the Bucket SDKs. Event listeners are useful for debugging and logging, but they really shine when you want to make Bucket data available in other systems.

For example, when debugging sessions in Datadog Session Replay, it’s useful to know which feature flags were enabled for the user. Sending feature flag checks to Datadog now only takes a few lines of code in the Bucket React SDK:

import { datadogRum } from "@datadog/browser-rum";
import { useClient } from "@bucketco/react-sdk";

function DatadogFlagEvalIntegration() {
  const client = useClient();
  useEffect(() => {
    return client?.on("check", (check) => {
      datadogRum.addFeatureFlagEvaluation(check.key, check.value);
    });
  }, [client]);
  return null;
}

‍

Similarly, If you’re using Bucket track() to monitor feature usage, you can now send these events to Amplitude easily:

import { amplitude } from "@amplitude/analytics-node";
import { useClient } from "@bucketco/react-sdk";

function AmplitudeTrackIntegration() {
  const client = useClient();
  useEffect(() => {
    return client?.on("track", (trackEvent) => {
      amplitude.track(trackEvent.eventName);
    });
  }, [client]);
  return null;
}

‍

See the full documentation for more information

We’ve just added remote feature configuration to Bucket. A dynamic, flexible approach to configuring feature behavior outside of your app – without needing to re-deploy it.

For example, you can use configs to configure AI models for your customers at runtime. With remote config, you can safely upgrade customers to the latest AI model or you can try different models for different segments of customers. If a new model is causing quality issues, you can easily roll back to a previous version.

You can also use configs to manage things like in-app copy. This means non-engineers can update the application on their own without touching the codebase.

How it works

Let’s say you’re using GPT-4o in your application and want the option to easily upgrade all or some customers to the latest version as soon as it arrives. Furthermore, you want to be able to give certain customers access to a competing model, Claude 3.7, to see if it outperforms GPT-4o.

Remote Config is based on JSON and is therefore highly flexible. You can decide which JSON payload to send to your application.

Here’s an AI configuration example:

All customers get gpt-4o from OpenAI as default except the two customers – Apex and Blaze – which get claude-3-7-sonnet from Anthropic.

When gpt-4o gets upgraded to the next version by OpenAI, you can simply go here to update the payload, or you can add a new, small beta segment to test the new OpenAI version, like so:

How to get started

To get started with Remote Config, you need to first upgrade to the latest version of our SDKs.

In the React SDK you can now use config when using useFeature:

const { config } = useFeature("sent-chat-message");

‍

As per our example in the screenshot above, if you’re authenticated as Adrian Borer or any user in the Logix or Hightrix companies, you’ll get this config:

Get user feedback on models

If you want to get user feedback on the models, you use Bucket’s requestFeedback, like so:

All feedback will be sent to the Feedback tab, right next to Remote Config, as well as to Slack, if you choose to.

To learn more about Remote Config, check out our documentation.

Happy shipping!

By default, when you create a new feature on Bucket, we'll suggest a feature key derived from the name. The format of the key is kebab-case by default. However, you may prefer to use a different naming convention. In some cases, it's just that you're used to SNAKE_UPPER_CASE from previous feature flagging providers. In other cases, a specific format might work better for the programming language of your choice.

Now you can define your feature key naming convention when creating a new feature. You can always customize the name of the key, but when picking a naming convention, Bucket will then enforce that new keys adhere to it.

When you create a feature today, the feature becomes available for use in your browser application through Bucket SDKs. That means the feature is retrievable through our public facing API using a publishable key. For most features, this is desirable because it lets you toggle features in your app UI. It also lets you build integrations right in your app.

However, once in a while you're working on something you need to keep secret from everyone. For this use-case, we've made it possible to mark features as secret on Bucket. Secret features are not retrievable with a publishable key — only with a secret key. That means you can use a feature on your backend and ensure that the feature key is never revealed to any users.

‍

When browsing companies or users, it’s much more fun to see company logos or user avatars, rather than randomly generated avatars.

So, we’ve shipped support for it!

‍

If you send the company logo URL as the avatar attribute on a company, we’ll display it in the UI. Similarly with avatars for users.

More updates soon!

‍

We’re always trying to make things simpler. As such, we’ve renamed the feature tabs and split them into tabs that each represent a clear use case. We’ve also improved the onboarding instructions per use case.

Clearer terminology

First, we’ve renamed  the “Targeting” tab to “Access”, which is easier to understand.his tab is all about controlling feature access.

Secondly, we’ve split “Analyze” into “Adoption” and “Feedback” to provide both of those use cases with more real estate. 

Here’s the new feature tabs – simple!

The new Feedback tab

The feedback tab includes a list of the latest feedback and a new satisfaction timeline that lets you easily track feature satisfaction trends over time. 

The satisfaction timeline gives you a rolling average of satisfaction scores for a feature alongside qualitative feedback. It’s a simple way to visualize overall feature satisfaction, evaluate whether a feature needs an iteration, and then track an iteration’s impact on satisfaction.

You can select different evaluation periods and timing windows to track the impact of feature iterations on satisfaction.

Use case-specific code examples

We’ve also added specific instructions and code examples to each tab so they’re relevant to each stage of the release process. 

When creating a feature, you're usually early in the development process and are only looking to implement a feature flag. That’s why the code example in the Access tab only contains the feature key. 

When you’ve reached the beta or general availability rollout stage, you’ll likely add adoption tracking and feedback collection. 

The code example in the Feedback tab looks like this:

Happy shipping!

You can now toggle features access directly on the company pages. This makes it even simpler to grant individual companies access to features in the Bucket UI.

In B2B, customers get feature access based on the subscription plan. However, it’s not unusual for them to be given access to features outside of their set subscription.

You can now grant individual companies access to features by flipping a toggle on the company page.

Another practical use case for toggles is enrolling early adopters into the Beta stage of a new feature.

Feature toggles don’t alter your existing feature targeting rules. They simply add additional companies to the targeting rules, which is useful for granting ad-hoc access without changing the core targeting rules of a feature.

Note: You cannot use feature toggles to disable feature access granted by targeting rules.

Happy toggling!