Cloudflare Flagship: Edge-Native Feature Flags with OpenFeature – Q&A

Cloudflare has launched Flagship, a feature flag service now in closed beta that runs directly on its global edge network. Built on the OpenFeature standard, it lets engineering teams roll out features and run experiments without redeploying code. Unlike traditional tools that rely on external flag evaluation services, Flagship evaluates flags locally inside Cloudflare Workers, reducing latency and improving reliability. Here’s everything you need to know in a question-and-answer format.

1. What is Cloudflare Flagship?

Flagship is a new feature flag service from Cloudflare, currently available in a closed beta. It is natively integrated with Cloudflare’s edge infrastructure, meaning flag evaluations happen directly within the Workers environment rather than through a separate, external service. This allows teams to control feature rollouts and run A/B tests without modifying or redeploying their code. The service is built on the open-source OpenFeature standard, ensuring portability and compatibility with other flag systems. Instead of calling an external flag management system every time a flag is needed, Workers fetch flag configurations from the edge and evaluate them locally, offering near-zero additional latency. Flagship is designed to simplify the lifecycle of feature flags—from creation to targeting to gradual rollouts—while leveraging Cloudflare’s global network for speed and scalability.

2. How does Flagship leverage OpenFeature?

Flagship is built on the OpenFeature open standard, which provides a vendor-neutral API for feature flag management. This means the service follows a common specification that works across different providers and programming languages. With OpenFeature, developers can write code that interacts with flags in a consistent way, whether they’re using Flagship or another OpenFeature-compatible system. In practice, this allows teams to integrate Flagship into their existing workflows without being locked into a proprietary interface. The standard also simplifies switching between flag providers in the future. Cloudflare has implemented the OpenFeature provider for Workers, enabling flag evaluation to happen at the edge with minimal overhead. By using OpenFeature, Flagship promotes interoperability and follows industry best practices for feature management.

3. How does Flagship differ from traditional feature flag services?

Traditional feature flag services typically run on centralized servers, requiring a client-side SDK to make remote calls each time a flag is evaluated. This introduces network latency and potential failure points. Flagship eliminates these issues by moving flag evaluation to the edge, inside Cloudflare Workers. Because Workers run on Cloudflare’s global network, flag checks happen locally on the same platform that serves requests. There is no round trip to an external service, so performance is drastically improved. Additionally, Flagship is deeply integrated with the Cloudflare ecosystem—you can combine it with other edge features like KV storage or Durable Objects. Traditional tools often require separate infrastructure to manage flags, while Flagship is a first-party service that benefits from Cloudflare’s built-in security, caching, and global distribution. The closed beta lets early adopters test these capabilities before a wider release.

4. What are the benefits of evaluating flags locally at the edge?

Local flag evaluation inside Workers offers several key advantages. First, it reduces latency dramatically because no external API call is needed—the flag state is already available in the Worker’s runtime. This is critical for high-traffic, real-time applications where every millisecond matters. Second, it improves reliability: if the external flag service were to go down, traditional systems might fail or degrade. With Flagship, the flag configuration is preloaded and evaluated locally, so the service remains operational even during network issues. Third, it simplifies architecture. Developers don’t need to manage separate client libraries or worry about caching flag definitions across regions. Fourth, because evaluation happens at the edge, it’s naturally distributed—users in Tokyo and London get the same fast experience. Finally, it aligns with Cloudflare’s philosophy of reducing complexity by keeping everything within a single platform.

5. How can developers use Flagship for experimentation?

Flagship enables developers to run A/B tests and gradual rollouts directly on the edge. Once a flag is created via the Cloudflare dashboard or API, teams can define targeting rules based on user attributes, such as geography, device type, or custom segments. For example, you could show a new checkout flow to 10% of visitors from the US and measure conversion rates. Because flag evaluation happens within Workers, you can combine it with analytics tools to capture real-time metrics. The OpenFeature integration also means you can write experiments in any language supported by Workers (JavaScript, TypeScript, Rust via WebAssembly). Since changes are made via flag configuration rather than code deployment, you can quickly ramp up or roll back an experiment without triggering a full CI/CD pipeline. This makes it ideal for agile teams that need to test hypotheses with minimal operational overhead.

6. What does the closed beta mean for users?

Currently, Flagship is in a closed beta, meaning it’s not yet available to all Cloudflare customers. Users must apply for access and be selected to try the service. During this phase, Cloudflare will gather feedback on functionality, performance, and ease of use. Closed beta participants can expect to test core features like flag creation, targeting, and local evaluation in Workers. The service is stable but may have limitations or changes before the general availability release. This is a great opportunity for early adopters to influence the product roadmap. Once the beta ends, Cloudflare will likely offer Flagship as part of its platform, potentially with pricing tiers. For now, interested developers should sign up on the Cloudflare dashboard to request access and start experimenting with edge-native feature flags.

7. How does Flagship integrate with Cloudflare Workers?

Flagship is designed from the ground up for Workers. The flag evaluation code runs directly in the same environment as your Worker script. Integration is straightforward: you import the OpenFeature provider for Cloudflare, initialize it with your flag configurations, and then call getFlagValue to check a flag. The flag data is fetched from the edge and cached locally for low-latency access. Because Workers are stateless, Flagship handles state internally using Cloudflare’s global network. There’s no need to install separate SDKs or manage external dependencies. You can also use Flagship alongside other Cloudflare services like KV (for storing flag definitions) or Durable Objects (for coordinating state). This tight integration means that feature flags become a first-class citizen in the Worker lifecycle, enabling sophisticated rollout strategies without leaving the Cloudflare ecosystem.