# Platform overview

> What the Konstrukt platform is intended for, its main building blocks and how data flows from source systems through models and calculations to apps, reports and integrations.

Konstrukt is a multi-tenant, browser-based platform for building planning and finance-operations solutions without writing application code. A solution is built from configuration: a data model, calculation scripts and app definitions. The platform provides storage, versioning, calculation scheduling, access control, the end-user interface and the integration surfaces.

## Intended use

The platform is built for processes where people and systems enter, adjust, calculate and report numbers over several dimensions. Typical examples:

- budgeting, forecasting and scenario planning;
- personnel and payroll-cost planning;
- revenue, agreement and recurring-revenue planning;
- project and investment planning;
- consolidation, eliminations, KPI reporting and month-end close support;
- operational registers that feed financial calculations, such as agreements, projects or units.

The same building blocks serve all of these. What differs between solutions is the model — the dimensions, value types, calculations and apps configured in each tenant. Konstrukt delivers ready-made models as templates.

## Building blocks

| Building block | Role | Documented in |
|---|---|---|
| Tenant | An isolated customer environment with its own host name, users and plans | [Concepts](concepts.html#tenant) |
| Plan | A complete data model: dimensions, value types, calculations, apps | [Concepts](concepts.html#plan) |
| Dimension and property | Categorical axes (account, department, month) and their attributes | [Data model](data-model.html) |
| Value type | A measure stored over a set of dimensions | [Data model](data-model.html#value-types) |
| Reference | A stored or point-in-time version of plan data | [References and history](references-history.html) |
| Calculation | A Kex script that derives and writes data automatically | [Calculations](calculations.html) |
| Kex | The query and scripting language | [Kex](kex.html) |
| App | The end-user interface: datasets, workspaces, components, actions | [Apps](apps.html) |
| Access control | Roles, groups, access lists, row-level access | [Security](security.html) |
| Integration and APIs | Imports, REST API, SQL views, MCP server | [Integration](integration.html), [APIs](apis.html), [AI agents](ai-agents.html) |

## How data flows

```flow
Source systems | ERP, payroll, CRM, files -> Import | configurations, API, MCP -> Plan data | value types over dimensions -> Calculations | Kex, run on change -> Apps | tables, charts, actions
Users | entry, spreading, actions -> Plan data | edits are versioned -> Calculations | dependants recalculated -> References | snapshots for comparison
Plan data -> External access | SQL views, REST, MCP -> BI and downstream systems
```

1. **Data enters** through configured imports (files, REST, storage), from users typing in apps, from actions, or from agents through the MCP server.
2. **Every change is versioned.** The platform keeps the full history of value-type data, so any earlier state can be queried. See [References and history](references-history.html).
3. **Calculations run automatically.** When data a calculation reads changes, the calculation and everything that depends on it is recalculated in dependency order. See [Calculations](calculations.html).
4. **Apps present and collect data.** Apps show datasets through tables, charts and metrics, let users enter and spread values, and run actions that execute Kex scripts. See [Apps](apps.html).
5. **Data leaves** through SQL views, the REST API, exports from apps and the MCP server. See [APIs and SQL access](apis.html).

## Configuration, not code

Everything in a solution is configuration held in the tenant:

- The data model is defined in the admin interface or through the MCP server.
- Calculation logic is written in [Kex](kex.html), either directly or through the guided calculation editor, which generates Kex.
- Apps are defined through the app editor. Underneath, each app is an XML configuration, which can also be read and written as JSON through the MCP server. See [App configuration](app-config.html).

Because the whole solution is data, it can be copied between plans, inspected by agents and changed without deploying software.

## Interfaces at a glance

| Interface | Audience | Purpose |
|---|---|---|
| End-user app interface | Planners, managers, controllers | Enter, review and report data |
| Admin interface | Solution builders | Model, calculations, apps, security, integrations |
| Kex console | Solution builders | Run ad-hoc Kex queries and scripts |
| REST API | Integrations | Import, execute Kex, manage entities |
| External SQL views | BI tools, data warehouses | Read plan and reference data with SQL |
| MCP server | AI agents | Read and change the model and data with tools |

### Interface language

The interface is available in **Swedish and English**, and more languages can be added. Each user chooses a language under **Settings** (the gear icon), see [Using apps](end-user.html#user-settings). All system texts follow the chosen language. Names defined in the model — dimensions, dimension values, value types, apps, workspaces, actions and so on — are stored as entered and are not translated.

This documentation uses the English interface labels and concept names, and gives the Swedish label in parentheses where it helps users of the Swedish interface, for example **Initial values** (*Initialvärden*). The [glossary](glossary.html) lists both.

## Related

- [Core concepts](concepts.html)
- [Architecture](architecture.html)
- [Glossary](glossary.html)
