Skip to content
← All articles

Technical guide · 1,567 words

What Is Admin Infrastructure?

Understand admin infrastructure and how shared schemas, operator interfaces, validation, permissions, and APIs reduce repetitive back-office work.

Most applications need an operational surface that customers never see. Support and operations teams use it to find records, correct data, manage access, import a dataset, or investigate a change. Building those screens and their permissions separately for every application is repetitive work. Admin infrastructure is the shared layer for that work: a data model, an operator-facing interface, and a governed API built from the same definitions.

The useful distinction is between operational data management and a customer product. Admin infrastructure is not just a table with CRUD buttons, a headless database, or a general-purpose internal-tool canvas. It connects a schema to forms and tables, validation, authorization, audit history, imports and exports, and a controlled programmatic boundary.

A practical definition

An admin-infrastructure system starts with a definition of the data an operator needs to manage. That definition includes fields, types, required and nullable behavior, uniqueness, defaults, options, and relationships. The system uses it to drive the management UI and the API contract instead of requiring the same rules to be reimplemented in several places.

In Dashier, the hierarchy is organization → project → data source → record. A data source stores its records in a metadata-driven structure: the source and its fields are fixed records, while record values are stored as JSON data. The source slug identifies the API and UI resource within a project. Field definitions are used by the forms, record validation, and REST handlers, so a field change has one place to start.

That does not mean every application workflow can be generated. It means the recurring part of administration—managing records safely and consistently—has a defined foundation.

What it is, and what it is not

Different from customer-facing UI

A customer-facing product should guide users through a focused workflow and hide implementation details. An admin surface has a different job: it gives authorized operators enough visibility and flexibility to search, filter, inspect, correct, and move data without putting those controls in the customer experience.

For example, an operator may need to find a record by a searchable field, edit a value, review its history, or export a filtered set. Those are data-management tasks, not necessarily product features. Keeping the surfaces separate lets each one fit its audience.

More than CRUD

Create, read, update, and delete are the basic operations, but they are not the whole system. A usable administrative layer also needs typed input validation, organization and project scoping, role-aware permissions, endpoint policies, and an explanation of what changed.

Dashier applies the source definition to both dashboard writes and REST writes. It validates values, checks references and unique fields, preserves server-generated ID fields, and records create, update, and delete actions in the organization’s audit log. A record lookup is scoped to its data source rather than treated as a global query.

Different from a headless data platform

A headless data platform is primarily an API or data layer for another application to present. That can be the right choice when a team already owns the operator UI. An API alone, however, does not provide the tables, forms, validation states, access controls, import flow, or audit trail that operators need.

Admin infrastructure can expose a headless API, but its center of gravity is the complete operational boundary. In Dashier, the generated UI and REST API consume the same source fields and policies rather than maintaining separate record contracts.

More opinionated than an internal-tool builder

A general-purpose internal-tool builder is useful when a workflow needs bespoke layouts, queries, or actions across multiple systems. Its flexibility also means that each tool becomes another application to design, permission, and maintain.

Admin infrastructure takes a narrower, repeatable path. It is a good fit for the common set of source-backed tables, forms, access rules, and data operations. An unusual multi-system workflow may still need custom code or another tool; not every workflow belongs in a generated CRUD surface.

The main layers

1. Resource ownership and isolation

The organization, project, and data-source hierarchy establishes where a record belongs. The server resolves a requested source through its project and organization, and record operations use the source ID. That scoping is part of the security model, not a convention left to the browser.

For a multi-tenant application, the important test is simple: can a caller provide an ID from another organization and learn anything about it? Organization scoping, server-side permission checks, and database row-level controls should all work together to make that request fail.

2. Schema and field metadata

Dashier supports fields such as text, textarea, number, decimal, boolean, email, phone, URL, date, datetime, JSON, image, file, enum, reference, array, rich text, and server-generated ID fields. References can describe one-to-one, one-to-many, or many-to-one relationships.

The type is behavior, not decoration. Number and boolean inputs are coerced and validated as those types; email and URL fields have format checks; enum values are checked against their configured options; references are checked against an existing record. Defaults, uniqueness, nullability, and required settings are applied through the same validation path used by the API and forms.

3. Generated administration

A source workspace provides the ordinary tools an operator expects: a list with search, filters, sorting, pagination, and bulk actions; create and edit forms; record views; and import and export controls. The exact control is selected from the source’s field metadata, so adding a field does not require hand-building a separate screen for it.

This generated surface is intentionally focused. It handles recurring source-backed administration, while a domain-specific customer flow remains application code.

4. Authentication and authorization

Authentication answers who is calling. Authorization answers whether that caller may perform the requested operation. Dashier’s organization UI uses the system role hierarchy Owner, Admin, Editor, and Viewer, and custom roles can receive explicit source-level grants for read, create, update, and delete operations.

REST endpoints have their own policy layer. A method can be public, authenticated, or role-protected, and it can be disabled or excluded from the API channel. API keys are project-scoped, can be revoked, and carry scopes; callers can send one with x-api-key or Authorization: Bearer. For an authenticated endpoint, the key must have the scope required by the method. A role-protected endpoint requires an admin-scoped key or an allowed session role.

The implementation also applies a per-policy rate limit, keyed by API key when one is present and otherwise by the forwarded client identity. The current limiter is in-memory and best-effort per server instance, so it is a request guard—not a claim of distributed rate-limit enforcement.

5. The REST boundary

The public REST routes use the source slug as the resource name:

GET    /api/v1/{source-slug}
POST   /api/v1/{source-slug}
GET    /api/v1/{source-slug}/{record-id}
PUT    /api/v1/{source-slug}/{record-id}
DELETE /api/v1/{source-slug}/{record-id}

A list request supports search, field filters, sorting, and pagination. A create or update request is validated against the source fields; validation errors return a structured response rather than writing an untyped object. The API resolves the key, project, source, fields, and endpoint policy before it reaches record logic.

For example, a read request can look like this:

curl https://app.example.com/api/v1/members \
  -H 'x-api-key: YOUR_API_KEY'

Here, members is only an example source slug. The record shape comes from the configured source, not from a universal Dashier schema.

6. Audit, import, and export

Administrative changes need a history. Record create, update, and delete operations write audit entries with the organization, actor, entity, action, and relevant old or new values. The import path also records the import action after a commit.

Imports accept CSV or JSON, map columns to source field keys, and can run in validation mode before writing. The implementation validates every row, checks duplicate values within the file and against existing records, and commits only after the validation pass succeeds. Exports support CSV and JSON and reuse the source’s search, sorting, and filtering behavior.

When admin infrastructure is a good fit

Use a customer-facing UI for customer workflows. Use a headless data platform when another application already owns the operational presentation. Use a general-purpose internal-tool builder when the core problem is a bespoke workflow spanning several systems.

Admin infrastructure fits when these concerns belong together:

  • typed, source-backed operational data;
  • generated tables and forms for recurring administration;
  • organization and project boundaries;
  • repeatable roles, API scopes, and endpoint policies;
  • imports, exports, and an audit trail; and
  • a REST contract that application code can call directly.

Before adopting one, test the contract rather than comparing screenshots. Can it model the fields and relationships you actually need? Are boundaries enforced on every request? Do the UI and API share validation? Can you control access per source and endpoint? Can operators explain a change later? And is there a clear escape hatch when a generated screen is not enough?

How Dashier approaches the category

Dashier keeps the data source at the center. A source belongs to a project, records carry organization scope, and field metadata drives the management UI and REST validation. The result is a focused foundation for recurring administration around an application’s data, not a second customer product and not a general workflow automation engine.

The current boundary is deliberate: Dashier provides source-backed administration, REST access, role and endpoint controls, file and image fields, relationships, CSV/JSON import and export, and audit logging. It does not turn every business process into a generated workflow, and it does not claim GraphQL, SDK generation, or automatic customer-facing website and form generation.

Dashier is admin infrastructure for modern applications. Learn how the product works in the documentation or explore features.