Product Decisions This Supports

Progressive Delivery Pipeline: Enables feature flags for canary releases, dark launches, and gradual rollouts with minimal risk, aligning with CI/CD and GitOps workflows. Reduces deployment frequency while increasing release confidence.
Vendor-Neutral Flag Management: Avoids lock-in to proprietary tools (e.g., LaunchDarkly, Unleash) by adhering to the OpenFeature CNCF spec, lowering total cost of ownership and simplifying migrations between providers.
Symfony-Centric Development: Accelerates development velocity by integrating feature flags natively into controllers (via attributes), services (via DI), and templates (via Twig), reducing boilerplate and cognitive load.
Observability-Driven Operations: Built-in Symfony Profiler integration provides real-time visibility into flag evaluations, context, and provider health, enabling faster debugging and compliance audits.
Security & Compliance: MIT-licensed with no proprietary dependencies, ensuring alignment with open-source policies, audit requirements, and internal tooling restrictions (e.g., no SaaS-based flag management).
Multi-Environment Strategy: Supports environment-specific flag configurations (e.g., EnvVarProvider for staging, RedisProvider for shared toggles in production) without code changes, simplifying DevOps workflows.
FrankenPHP & Long-Running Runtimes: Explicitly designed for compatibility with FrankenPHP worker mode and other long-running PHP runtimes, ensuring stability in modern architectures.

When to Consider This Package

Adopt When:

Your Symfony application requires feature flags for:
- Progressive rollouts (e.g., 5% of users → 100%).
- A/B testing (e.g., comparing checkout flows).
- Kill switches (e.g., disabling a broken feature instantly).
- Environment-specific toggles (e.g., staging vs. production).
You prioritize vendor neutrality and want to avoid lock-in to a single feature flag provider (e.g., LaunchDarkly, Unleash).
Your team uses Symfony’s attribute system (#[Route], #[ParamConverter]) and wants a consistent syntax for feature flags (#[FeatureFlag], #[FeatureGate]).
You need Twig integration to dynamically render UI elements based on flags (e.g., showing a beta banner only to flagged users).
You’re using FrankenPHP, RoadRunner, or other long-running PHP runtimes and need feature flags that work reliably in these environments.
You want quick prototyping with built-in providers (InMemory, EnvVar, Redis) before adopting a dedicated backend.

Look Elsewhere If:

You’re not using Symfony: This bundle is Symfony-specific. Use the OpenFeature PHP SDK directly for other frameworks.
You need advanced targeting (e.g., multi-variate testing, gradual rollouts by user attributes) without a dedicated provider: Built-in providers ignore EvaluationContext, limiting dynamic targeting.
Your team lacks DevOps resources to manage a feature flag backend (Flagd, ConfigCat, etc.). Built-ins are static/config-driven and require restarts for changes.
You require real-time flag updates without redeploys (EnvVar/InMemory providers need app restarts; Redis requires external infrastructure).
You need audit logs, access controls, or compliance features (e.g., GDPR data subject requests). Built-in providers lack these capabilities.
Your application is highly distributed (e.g., microservices with inconsistent contexts). The EvaluationContext must be carefully managed to avoid stale or incorrect flag evaluations.
You’re using legacy Symfony versions (<6.4) or PHP <8.2, as this bundle has strict version requirements.

How to Pitch It (Stakeholders)

For Executives (CTO, VP Engineering, Product):

*"This bundle lets us control feature releases with precision—rolling out updates to subsets of users, killing broken features instantly, and testing new flows without redeploying. By using the OpenFeature standard, we avoid vendor lock-in and can switch between tools (e.g., self-hosted Flagd or SaaS like ConfigCat) without rewriting code.

Key benefits:

Faster, safer releases: Gradual rollouts reduce risk of outages.
Data-driven decisions: A/B test features and measure impact in real time.
Lower costs: Start with simple built-in providers, then scale to enterprise tools as needed.
Compliance-ready: Open-source with no proprietary dependencies—easier audits and vendor negotiations.
Symfony-native: Integrates seamlessly with our existing stack, reducing dev time and operational overhead."*

Ask: "Should we prioritize this for our next [product launch/A/B test/security kill switch]?"

For Engineers (Devs, Tech Leads):

*"This is the Symfony way to do feature flags—no more scattered if ($featureEnabled) checks or third-party SDKs. Here’s why it’s a game-changer:

For Developers:

Attributes over boilerplate: Use #[FeatureFlag] and #[FeatureGate] in controllers like dependency injection. Example:
```
#[FeatureGate('new_checkout')]
public function checkout(): Response { ... }
```
Twig support: Check flags in templates with feature('flag') or feature_value('flag', default).
Provider flexibility: Swap between:
- InMemoryProvider (local dev),
- EnvVarProvider (bootstrap toggles),
- RedisProvider (shared flags),
- Enterprise providers (Flagd, LaunchDarkly) later—no code changes.

For DevOps:

Built-in providers work with existing tools (Redis, env vars).
Profiler integration: See flag evaluations, context, and provider health in Symfony’s built-in tool—no custom logging needed.
FrankenPHP-safe: Works in worker mode out of the box.

For PMs/Product:

Gradual rollouts: Toggle features to 1% of users → 100% without redeploys.
Kill switches: Disable broken features instantly via env vars or Redis.
A/B testing: Target flags by user attributes (e.g., region: 'eu').

Get started in 5 minutes:

composer require aubes/openfeature-bundle

Then configure flags in config/packages/open_feature.yaml and use them anywhere."*

For DevOps/Platform Teams:

*"This bundle simplifies feature flag infrastructure while keeping options open:

Why it fits our stack:

No new dependencies for simple use cases: Use EnvVarProvider for kill switches or RedisProvider for shared toggles—no SaaS or self-hosted backend needed upfront.
Enterprise-ready: Plug in Flagd, ConfigCat, or LaunchDarkly later without app changes.
Observability: Symfony Profiler shows flag evaluations, context, and provider status—no custom dashboards needed.
Resilient: If Redis/Flagd fails, flags fall back to defaults (no app outages).
FrankenPHP/RoadRunner compatible: Tested for long-running PHP runtimes.

Migration path:

Start with InMemoryProvider for local dev.
Move to EnvVarProvider for staging/kill switches.
Add RedisProvider for shared flags in production.
Swap to Flagd/ConfigCat when you need targeting/rollouts.

Ask: ‘Should we standardize on this for all new feature flag use cases?’"*

For Product Managers:

*"This enables data-driven releases with minimal risk. Here’s how it helps us:

For Launching Features:

Dark launches: Ship features to 0% of users, then gradually roll out to 100%.
A/B testing: Compare variants (e.g., new checkout vs. old) by user segment (e.g., country: 'US').
Kill switches: Disable broken features instantly via env vars or Redis.

For Reducing Risk:

No big-bang releases: Test features with a subset of users before full rollout.
Instant rollback: Flip a flag to disable a feature if bugs emerge.
Compliance: Open-source with no proprietary tools—easier audits and vendor negotiations.

For Measuring Impact:

Symfony Profiler: See which flags are active, who’s affected, and why (context).
Integration with analytics: Log flag evaluations to tools like Mixpanel or Amplitude.

Example workflow:

Dev: Implements a new feature behind a flag (#[FeatureGate('new_dashboard')]).
QA: Tests with InMemoryProvider (flag = false).
Staging: Uses EnvVarProvider (flag = true for testers).
Production: Rolls out to 1% of users via Flagd/ConfigCat, then scales.

Ask: ‘Can we use this for our next [product experiment/launch/security patch]?’"*

Openfeature Bundle Laravel Package