Read Nona through the standard OpenFeature API.
Nona ships official OpenFeature providers for JavaScript backends, browser apps, and .NET services. Application code reads flags through the vendor-neutral OpenFeature interface while Nona still owns the projects, environments, scopes, and history underneath.
Why OpenFeature
A standard interface, Nona underneath.
Nona already works through plain HTTP and official clients. OpenFeature adds a different benefit: application code depends less on a Nona-specific API, flag reads can look the same across projects, and teams that already use OpenFeature can adopt Nona without inventing a custom abstraction.
Nona stores values with logical content types — boolean, number, text, and json— which map cleanly onto OpenFeature's boolean, numeric, string, and object value resolution.
Where this pairing is useful
OpenFeature gives you the application-side abstraction, while Nona still provides the underlying projects, environments, scopes, API keys, history, and rollback.
- Standardizing flag reads across services that don't all use Nona directly
- Letting a team that already thinks in OpenFeature adopt Nona with no bespoke client code
- Keeping application code portable if the backing flag system ever changes
- Using the same OpenFeature API on the server and, after hydration, in the browser
Three provider packages
Each package is listed as a vendor-official provider on the OpenFeature ecosystem page. Install the one that matches your runtime.
JavaScript (server)
nona-openfeature-providernpm install nona-client nona-openfeature-provider @openfeature/server-sdk
import { OpenFeature } from "@openfeature/server-sdk";
import { createNonaOpenFeatureProvider } from "nona-openfeature-provider";
await OpenFeature.setProviderAndWait(
"nona-production",
createNonaOpenFeatureProvider({
baseUrl: "https://nona.example.com",
apiKey: process.env.NONA_API_KEY,
environmentId: "production",
})
);
const client = OpenFeature.getClient("nona-production");
const enabled = await client.getBooleanValue("Features:Checkout", false);Evaluates asynchronously, per request. Maps config_entry_not_found to FLAG_NOT_FOUND; other HTTP failures remain provider errors.
JavaScript (browser)
nona-openfeature-web-providernpm install nona-client nona-openfeature-web-provider @openfeature/web-sdk
import { OpenFeature } from "@openfeature/web-sdk";
import { createNonaOpenFeatureWebProvider } from "nona-openfeature-web-provider";
await OpenFeature.setProviderAndWait(
createNonaOpenFeatureWebProvider({
baseUrl: "https://nona.example.com",
apiKey: "your-frontend-api-key",
environmentId: "production",
})
);
const client = OpenFeature.getClient();
// Synchronous — the snapshot is already in memory.
const enabled = client.getBooleanValue("Features:Checkout", false);Loads the whole frontend-scoped environment as one snapshot, then resolves flags synchronously from memory. Needs a frontend-scoped API key.
dotnet add package Nona.Client dotnet add package Nona.OpenFeature.Provider
using Nona.Client;
using Nona.OpenFeature.Provider;
using OpenFeature;
using var nona = new NonaClient(new NonaClientOptions
{
BaseAddress = new Uri("https://nona.example.com"),
EnvironmentId = "production",
ApiKey = Environment.GetEnvironmentVariable("NONA_API_KEY")
});
await Api.Instance.SetProviderAsync("nona-production", new NonaOpenFeatureProvider(nona));
var featureClient = Api.Instance.GetClient("nona-production");
var enabled = await featureClient.GetBooleanValueAsync("Features:Checkout", false);Built on top of a configured NonaClient, so the provider only needs the client instance.
How Nona values map into OpenFeature
booleanboolean flags
numbernumeric values
textstring values
jsonobject values
Runtime behavior worth knowing
Polling
The web provider re-checks Nona every 30 seconds by default, sending the snapshot's ETag so an unchanged environment costs a 304. Set pollIntervalMs: 0 and call provider.refresh() to control refresh timing yourself.
Change events
When values change, the web provider emits PROVIDER_CONFIGURATION_CHANGED with the changed keys — what triggers re-evaluation in the web SDK and re-renders in the React SDK.
Releases
Both JavaScript providers pass construction-time useReleases and releaseVersion options through to nona-client; source routing stays in the underlying client.
Targeting
Nona snapshots are currently the same for every caller. Setting an evaluation context is safe and forward-compatible, but today it only causes a refetch.
Why the pairing works
- Application code depends less on a Nona-specific API.
- Flag reads look the same whether the backing system is Nona or something else.
- Teams that already standardize on OpenFeature can adopt Nona without a custom abstraction.
- Nona still owns the operational model underneath — projects, environments, scopes, API keys, history, rollback.
What OpenFeature doesn't change
OpenFeature only changes the application-side interface — it does not add percentage rollouts, user targeting, segmentation, or experimentation to Nona. Nona snapshots are the same for every caller today, so setting an evaluation context is safe and forward-compatible, but it only triggers a refetch.
Frequently asked questions
Does Nona support OpenFeature?
Yes. Nona ships official OpenFeature providers for JavaScript server applications (nona-openfeature-provider), JavaScript browser applications (nona-openfeature-web-provider), and .NET services (Nona.OpenFeature.Provider). Nona is listed as a vendor-official provider on the OpenFeature ecosystem page.
Is Nona listed on openfeature.dev?
Yes. Search the OpenFeature ecosystem page for "Nona" to find the vendor-official server, client, and .NET provider entries alongside the rest of the OpenFeature provider ecosystem.
Do I need a different package for the browser?
Yes. The OpenFeature server SDK evaluates asynchronously per request against a dynamic context; the web SDK evaluates synchronously against a static, preloaded snapshot. Nona ships nona-openfeature-provider for the server SDK and nona-openfeature-web-provider for the web SDK.
Does OpenFeature replace Nona's operational model?
No. OpenFeature only changes the application-side read interface. Nona still provides the projects, environments, scopes, API keys, history, and rollback underneath.
Should I start with OpenFeature or the direct Nona client?
Usually only start with OpenFeature if your team already thinks in OpenFeature terms. Otherwise, many teams start with the direct client or raw HTTP first, then add OpenFeature once the basic read path is proven.
Resolve one flag through OpenFeature.
Wire up a provider, resolve a single boolean flag, and confirm the value changes when you edit it in Nona — before you expand into broader usage.
Get started