Tenant-specific feature flags in Node.js usually return the wrong value because the SDK evaluates a different context from the one your application intends—not necessarily because its cache is stale. First identify whether the SDK uses a context passed on every evaluation or a client-side current context; then inspect the exact tenant identity and attributes supplied when the flag is evaluated.
Start by identifying the SDK and its context model
The right diagnosis depends on how the SDK receives identity. LaunchDarkly distinguishes server-side SDKs, which can serve multiple users and evaluate against the context passed to each call, from client-side SDKs, which maintain current context state. A remedy for one model may be irrelevant to the other.
| Evaluation model | Where identity comes from | What to check |
|---|---|---|
| Server-side per-call evaluation | The context passed to the individual flag evaluation. The SDK does not adopt attributes just because they appeared in a context list or another SDK instance. | Confirm that each call includes the intended tenant targeting key, context kind, and every attribute required by the rule. LaunchDarkly: identifying and changing contexts; LaunchDarkly: flag evaluation |
| Client-side current-context switching | The context currently held by the SDK. After an identify operation starts, evaluations may continue to expose values associated with the previous context until the transition completes. | Wait for identify to resolve before evaluating for the new tenant, and handle rejection. A failed transition can leave old-context values available. LaunchDarkly: identifying and changing contexts |
| OpenFeature context layers | Context may be supplied globally, on a client, and for an individual invocation; the layers are merged for evaluation. | Inspect the origin and merge behavior of tenant fields at all three levels. Long-lived global or client data can conflict with the request’s intended tenant context. OpenFeature Node.js SDK; OpenFeature evaluation context |
LaunchDarkly’s Node.js server-side SDK and its server-side OpenFeature provider document per-evaluation context use and local rule storage. Those are separate concerns: a correctly updated rule set cannot fix a call that supplies the wrong tenant context. LaunchDarkly Node.js SDK reference (server-side); LaunchDarkly OpenFeature provider for Node.js (server-side) SDK
Inspect the context at the flag call
Compare one request that gets the expected value with one that does not. At the evaluation call site, record a privacy-safe diagnostic containing the flag key, tenant targeting key, context kind, required targeting attributes, returned value, and whether the result was a fallback or an evaluation error. This is a practical diagnostic format, not a vendor-prescribed logging schema; avoid logging sensitive tenant or user data unnecessarily.
Recommended Free Tools
#1 Best Overall
- Trace tenant identity to its source. Confirm the tenant key is derived from the authenticated request or other trusted identity source, rather than a shared default, stale singleton, or unrelated user identity.
- Check the context shape. Verify that the provider expects the context kind and key format you are supplying. LaunchDarkly requires a targeting key; when the context kind is omitted, it treats the context as a user context. LaunchDarkly: flag evaluation; LaunchDarkly Node.js SDK reference (server-side)
- Compare required rule attributes. Include the targeting attributes the flag rule actually uses on each server-side evaluation call. Do not assume that another call, context list, or SDK instance has populated them for this evaluation. LaunchDarkly: flag evaluation
- For OpenFeature, inspect all context layers. Find where global, client, and invocation values originate, and confirm the merged context represents this request’s tenant. A tenant value left on a long-lived layer can conflict with an invocation’s intended identity.
Determine whether the value is a fallback
An unexpected fallback is not evidence that the tenant matched a rule selecting that variation. LaunchDarkly documents fallback use when evaluation cannot proceed, including an unreachable service, an unknown flag key, a missing context key, or authentication failure. Check the SDK’s evaluation status or error information alongside the returned value, then verify the flag key, context key, credentials, initialization, and connectivity. LaunchDarkly: flag evaluation
Make fallback handling observable in the application. If the caller sees only a variation and discards evaluation details, a failed evaluation can look like a legitimate tenant-specific decision.
Check client-side identity changes for timing and failure
If the application switches a client-side SDK from one tenant context to another, treat identify as an asynchronous transition. Evaluating immediately after starting the switch can read values associated with the old context. Await completion before using flags for the new tenant; catch and handle a rejected identify operation rather than silently proceeding as if the new identity were active. LaunchDarkly: identifying and changing contexts
Do not apply this identify remedy to a server-side per-call evaluation. There, the key question is whether the correct tenant context is passed to that particular evaluation.
Investigate rule updates only after context and errors
LaunchDarkly documents that its server-side Node.js SDK keeps rules locally and receives updates through a persistent connection. Local evaluation and update delivery are distinct from the application’s choice of context. Once context construction and fallback/error behavior check out, inspect SDK initialization and update connectivity using the relevant server-side SDK or provider documentation. LaunchDarkly Node.js SDK reference (server-side); LaunchDarkly OpenFeature provider for Node.js (server-side) SDK
The cited documentation does not establish a universal refresh interval or freshness service-level guarantee. Without evidence from the particular deployment, a stale cache should remain a hypothesis, not the diagnosis.
Rank #4
A practical diagnosis order
- Identify the package and whether it is a server-side per-call SDK, a client-side current-context SDK, or an OpenFeature integration.
- Inspect the exact context at the evaluation call: tenant key, kind, and rule-required attributes.
- Trace the tenant key to the authenticated request and check for shared defaults or stale state.
- If OpenFeature is involved, inspect global, client, and invocation context and how their values merge.
- If a client-side context is changing, await identify and handle its failure before consuming the new tenant’s flags.
- Distinguish a valid targeting result from a fallback or evaluation error; check the flag key, context key, credentials, initialization, and connectivity.
- Only then investigate rule synchronization and local SDK state.
These checks address distinct implementation choices; they do not establish a fair cross-vendor performance comparison or a universal freshness guarantee.
Quick Recap
Best Value
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.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →
