Skip to content

Write your product. Accounts, permissions and billing are already underneath.

Build your product as a UniCore plugin: one .NET assembly and no frontend for the admin console, on top of multi-tenant accounts, sign-in, permissions, plans, usage metering and invoicing.

At a glance

Who this is for

Teams building industry software for a specific trade

Agencies serving many small businesses from one platform

Product teams whose value is the domain, not the plumbing beneath it

What you would otherwise build yourself

Every product needs the same foundation: accounts, sign-in, permissions, multi-tenancy, plans, usage metering, invoices, data export, deletion and an admin console. You have built it before and would build it again for the next product. UniCore carries it, and you write the product.


What you get

One assembly, one hard boundary

A plugin is a single .NET assembly that references only the SDK. A compiler analyzer fails the build if it reaches into the platform internals, so your plugin stays separable and upgradable by construction.

An admin console you don't write

Declare settings, collection, insight and action panels in your manifest and the dashboard renders them, including forms, grids and foreign-key pickers. None of it needs frontend code in the plugin.

Your data model, managed for you

Declare a domain and the platform provisions it under your plugin slug. That keeps the names of two products apart, and a clash is refused. Schema changes go through a forward-only migrator you control.

A published API with up-to-date docs

Turn on the domain API and the platform serves OpenAPI, a browsable Swagger UI and typed CRUD straight from your loaded plugin, including an optional anonymous read surface for public pages.

Billing, metering and erasure in the SDK

Declare products and create subscriptions. Reserve usage on a credits or tokens meter, then commit or release it. Operators set allowance and price. For erasure, you poll tombstones and delete your own per-user data.

Deploy without a restart

Upload and install a signed assembly, and each host that needs it loads it in place. During the swap its routes answer 503 with Retry-After: 1. If the new version fails to load, the previous one keeps serving.

How it works

  1. Start with the SDK

    Reference the SDK package and declare a manifest: identity, version, the hosts you need, permissions, routes and release notes.

  2. Declare your domain

    Describe definitions, fields and relations in a forward-only migrator. The platform runs it on install, each newer one on upgrade, and stamps the schema with that version.

  3. Write your endpoints

    Declare each route with its gate: a permission, signed in or anonymous. The operator sees the list at upload. An anonymous route can set its own per-IP request budget and body limit.

  4. Declare the admin surface

    Describe forms, grids, insight panels and action buttons as manifest data. Other pages can ship as a single JavaScript bundle.

  5. Verify in CI

    Analyzers also fail the build on SDK members newer than your pinned version. In CI, 'dotnet unicore-plugin verify' checks the built DLL: boundary, manifest, SDK calls and routes.

  6. Install and adopt

    Install the plugin system-wide, or let a tenant's administrator adopt it where your policy allows. Adoption provisions that tenant's schema and templates, and your lifecycle hook can add initial data.

What ships with UniCore and what you write

Everything on the left is part of UniCore and maintained by us. Everything on the right is yours to write.

Ships with UniCore

Multi-tenant accounts and tenant isolation, with sessions, session renewal and email and password sign-in

Google, Microsoft or your own OIDC provider, plus Apple on mobile (Platform package)

Roles, named permissions and row-level access to platform records, plus organization units and access requests for those records

A schema-managed data store with migrations, and background jobs with cron schedules per tenant

Messaging between hosts, and a per-user "data changed" signal on the SSE stream

Notifications by email in every package. The Platform package adds Telegram, Discord and WhatsApp, with templates and routing the operator edits, and approve and reject buttons in Telegram and Discord messages

Products, subscriptions and entitlement gates

Usage metering with reserve, commit and release

GDPR erasure for accounts, with a tombstone feed for your own data, and data export

Audit logging (Platform package)

An admin console rendered from your manifest

OpenAPI and Swagger for your own API, and release notes for your own versions

You write

Your domain model

Your business rules

Your customer-facing screens, starting from React storefront components

Frequently asked questions

Your question isn't listed? Tell us briefly what it's about.

The SDK offers PDF documents from manifest templates, cron schedules per tenant and typed filters, booleans included. Attachments are currently kept as metadata. Operators grant credits, and one-time charges are recorded. A file or blob facade, pipeline blocks contributed by a plugin and invoicing of one-time charges are built as needed or on request.

Yes. You build against the SDK package alone, and the platform source stays out of the picture. The plugin then runs inside the host with full rights. That is why uploading is reserved for main-tenant administrators, and outside Development the plugin carries a trusted signature. A sandbox for plugins can be built on request.

Each tenant adopts the plugin separately, and every call through the SDK facades is scoped to the tenant by the host. The platform takes care of tenant filters for you. This scoping covers all access through the facades, so route your data access through the SDK throughout.

Upgrades are deliberate. A newer binary is marked as a pending update, and an administrator starts the upgrade job, for one tenant or all. Uninstall keeps data and templates. Purge is final. It offers an export first and asks you to type the plugin slug to confirm.

See it applied to your own use case

Thirty minutes, screen-shared: a relay, a plan, a metered call and an invoice, then your API or product idea. No slide deck.

Compare the three packages