Use configuration management for settings that operate or tune the service broadly; use feature flags when the application must choose a capability or variant for a tenant, user, or rollout cohort. They can share a delivery platform, but they serve different purposes. In a multi-tenant Node.js app, evaluate flags with trusted, request-scoped context—and enforce authorization and tenant data isolation independently.
What is the difference?
Configuration describes settings that influence how an application behaves, often across an environment or service. Feature flags answer a narrower, conditional question: should this capability, or which version of it, apply in this evaluation context? The categories can overlap operationally. AWS AppConfig, for example, supports both feature-flag and freeform configuration profiles; the distinction is what the data means to the application, not necessarily which system stores it. AWS explains the two AppConfig profile types.
| Decision point | Configuration management | Feature flags |
|---|---|---|
| Question answered | What broad setting should this service use? | Should this capability or variant apply to this evaluation subject? |
| Typical scope | Application, service, or deployment environment | Potentially a tenant, user, cohort, or release population |
| Typical examples | Logging level or service limits | Enable a new workflow for selected tenants, or choose a variant by rule |
| Change path | Depends on the configuration system and application integration | Depends on the flag provider and application integration |
| Release targeting | Not inherent to general settings | A common use, but targeting and rollout capabilities vary by provider |
The change-path row is deliberately provider-dependent: do not assume a setting requires a restart, or that a flag change reaches every process immediately. Check the chosen system’s documented refresh, cache, consistency, and failure behavior.
When should a multi-tenant app use each?
Put operational settings in configuration
Use configuration management for values whose purpose is to operate or tune the service broadly rather than decide product exposure for an individual tenant. Examples include logging verbosity and service limits. Keep settings with different deployment scopes clearly separated so a service-wide operational change is not mistaken for a tenant-specific product decision.
#1 Best Overall
Use a flag for conditional product behavior
Use a flag when behavior should depend on release state or evaluation context—for example, enabling a redesigned workflow for a controlled set of tenants, or selecting a variant for a user or cohort. Choose the evaluation unit deliberately: a tenant rollout should be keyed by tenant; a user experiment may need a user key instead. A stable targeting key helps providers apply rules or fractional evaluation consistently. The OpenFeature specification defines it as uniquely identifying the subject of an evaluation.
Use both when delivery and decision are separate
A configuration platform can store and distribute flag definitions while application code evaluates a flag against request context. AppConfig is one documented example: its multi-variant flags evaluate supplied context against user-defined rules and can return a value for segmentation or traffic splitting. That shared infrastructure does not make a flag equivalent to every other configuration value. See the AppConfig feature-flag and freeform profile documentation.
How to evaluate a flag safely per tenant in Node.js
- Authenticate and resolve the tenant first. Obtain the tenant identifier from trusted authenticated state or validated server-side routing, not an unvalidated identifier supplied by a caller.
- Choose the subject key. Use the tenant as the targeting key when the rollout unit is the tenant; use an appropriate user or service identity when that is the intended unit. A separate tenant field can be included when a rule needs both dimensions.
- Pass context for this evaluation. Keep request-specific tenant and user attributes scoped to the request or flag invocation. Do not mutate global evaluation context to represent the current request in a concurrent Node.js server.
- Evaluate with a deliberate fallback. Define the fallback for an unavailable, missing, or otherwise unsuccessful evaluation according to the feature’s risk. A fallback selects behavior; it does not grant access.
- Check authorization at the protected operation. Independently verify permissions and scope every data access to the authenticated tenant, whether the flag is on or off.
OpenFeature’s Node.js server SDK is designed for Node.js 18 and later. Its documented setup flow is to install @openfeature/server-sdk, register a provider, initialize it before relying on evaluations, obtain a client, and evaluate flags with fallback values. The SDK documents global, client, and invocation context, plus transaction context propagation for carrying request attributes through a call chain. See the OpenFeature Node.js SDK documentation and its evaluation context guide for provider-specific setup and context APIs.
Keep context lean. OpenFeature cautions that providers may serialize evaluation context and may handle or persist it. Pass only attributes needed for a rule, and understand the provider’s data handling before including personal information such as an email address. A tenant key can be enough for a tenant rollout; adding more user details is not automatically better.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Scan for outdated or missing drivers - takes under a minute3Repair Windows errors before they cause bigger problemsA flag is not an authorization boundary
A feature flag selects application behavior. It should not be the authority that decides whether a user may read or modify a tenant’s records. A tenant-specific flag can control whether the interface or implementation path for a feature is exposed, but the operation that accesses protected data still needs independent permission checks and tenant scoping. This separation is an application-security design rule, not a guarantee made by a flag SDK.
- Use trusted identity and authorization logic to establish which tenant and resources the caller may access.
- Use the flag only to select eligible behavior after the application has established that context.
- Do not let possession of a tenant identifier, or a positive flag evaluation, stand in for permission to access that tenant’s data.
What operational controls should you compare?
Evaluation syntax is only one part of selecting an approach or provider. Compare the controls that determine how changes are targeted, released, observed, and recovered.
Rank #4
| Area | Questions to answer |
|---|---|
| Targeting | Can rules target the intended tenant, user, or cohort? Is the subject key stable, and are variants supported where needed? |
| Validation and rollout | How are definitions validated before release? Can rollout be staged, paused, or limited to an environment or population? |
| Rollback and observability | How are changes monitored, who can reverse them, and what happens when a deployment alarm fires? |
| Failure behavior | What fallback, local cache, stale-value, startup, and provider-outage behavior is documented for the actual SDK and provider? |
| Security and governance | Who may change or evaluate settings? Are changes auditable, and what context data does the provider receive or retain? |
| Node.js lifecycle | Does the SDK support the runtime in use? How is request context propagated in asynchronous code, and what initialization or shutdown work is required? |
AWS AppConfig illustrates why deployment controls deserve separate attention from evaluation. Its documentation describes deployments in terms of an environment, configuration version, deployment strategy, and KMS key; it also describes validation and CloudWatch alarms that can trigger rollback. These are documented AppConfig capabilities, not universal properties of configuration or flag systems. Review AWS AppConfig deployment guidance and verify the behavior of any candidate provider in the environment you will run.
Quick Recap
Best Value
How to keep the design maintainable
- Document each flag’s owner, purpose, default, and evaluation scope. State whether it is tenant-, user-, or cohort-targeted.
- Set a retirement trigger for temporary release flags. Remove them when the rollout purpose ends instead of allowing old branches to accumulate.
- Separate product entitlement from rollout state. If billing or domain rules determine eligibility, enforce those rules in trusted application logic; a flag may shape product behavior but should not be the sole record of permission.
- Test tenant boundaries independently of flag states. A test matrix should include both flag outcomes while verifying that one tenant cannot cross into another tenant’s data.
- Validate provider assumptions before depending on them. Check current documentation for refresh timing, permissions, cache behavior, consistency, outage semantics, and SDK lifecycle requirements; these are not established uniformly across providers.
A practical decision rule
- Choose configuration management for broad operational settings such as logging level or service limits.
- Choose a feature flag when a capability or variant must depend on a tenant, user, cohort, or controlled release state.
- Use a configuration platform to distribute flag definitions if it fits, while keeping the flag’s context-based evaluation distinct from ordinary settings.
- Keep authorization, billing entitlements, and tenant data isolation in trusted domain and access-control logic.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Free tools Windows power users keep installed
One-click scans. No signup required.
