User guide.

What is nxr.ai

nxr.ai is an open source no-code platform for document-heavy work. You use it to build the application around a document process: the data it needs, the screens where people enter, check and approve that data, and the documents, emails and AI-generated content it produces.

Many business documents can't be written in a single pass. Audit reports, contract summaries, offers and course certificates depend on structured data, fixed rules and people checking the work. In nxr.ai, you build that process as an app:

• Data — tables and the relationships between them, entered by hand, imported from Excel, or extracted from uploaded documents with AI.
• Screens — grids, forms and buttons where your team and your clients work with the data, each seeing only what their role allows.
• AI — agents that extract information and propose structures, and blocks that draft text, using your own data and reference material.
• Documents — PDF and email templates filled from your data, with conditions and loops.

You can use the hosted service at nxr.ai, or run nxr.ai on your own infrastructure: it's MIT-licensed and installs with Docker.

Who it's for. nxr.ai is built for the people who design business processes — consultants, integrators and operations teams who know how a document should be produced and want to turn that knowledge into a tool others can use. Building an app takes some learning; using a finished one doesn't.

How to use this guide

• New to nxr.ai? Start with Create your first app, then Build your first document workflow.
• Want to understand the approach? Read How document workflows work.
• Looking up a feature? Building apps, Templates and AI features cover each one.
• Running nxr.ai yourself? See Self-hosting.

Hosted or self-hosted

You can move between the two in either direction. [CHECK: how an app moves between hosted and self-hosted, given that app structure can't be exported. If it can't be moved, remove this sentence here and the matching answer on the pricing page.]

See Pricing for plan details and Self-hosting for installation.

How an app fits together

Every nxr.ai app is built from the same few parts.

1. Tables store your data as records. Relationships connect them: a contract has many clauses.
2. Screens show the data in grids and form components. A screen's input is the record it's about — the contract you're looking at.
3. Buttons run actions: save a record, send an email, generate a PDF, run an AI agent, open another screen.
4. Templates produce output from your data. PDF templates produce documents, email templates produce emails, and AI agents send your data to AI and write the results back into records.
5. AI blocks sit inside templates and draft text as a document is generated.
6. Roles decide who can see which screens and records.

[DIAGRAM: app-parts] Tables and relationships → screens with grids and forms → buttons and actions → templates (PDF, email, AI agent), with AI blocks inside templates and roles framing who sees what. Alt text: "The parts of an nxr.ai app: tables feed screens, buttons on screens run actions, and templates turn data into documents, emails and AI results, while roles control access."

A typical path through an app: a user picks a contract in a grid, a button opens that contract's screen, an AI agent extracts its key terms, the user corrects a field in a form, and another button generates the summary PDF.

You build all of this in Edit mode, and switch to Live mode to use the app as your users will. Most things are added the same way: type / on an empty line to insert a grid, component or button, or type it in a text field to insert a variable.

Key terms

Action — what a button does when it's selected: save or delete a record, set a field, run an AI agent, generate a PDF, send an email, call an API, or open another screen.

AI agent — a template that sends a prompt, filled with data from your app — including uploaded files — to AI, and writes the result back into records. For example, it can extract the clauses of an uploaded contract into a table.

AI block — an element inside a template that combines prompt text with variables. When the document is generated, the AI's answer appears in its place.

AI command — an instruction you type in Edit mode to change your app, from adding a field to building a complete document workflow.

App — an application you build in nxr.ai: its tables, screens, templates, roles and users. Each app has its own data and its own users.

Component — an element on a screen that shows or edits one field, such as a text input, dropdown, date picker or file upload.

Document workflow — an app that extracts information from source documents, structures it, has people review it, and generates a finished document. The AI command that builds one starts with "Create a pipeline for…".

Editor — someone who builds or changes apps, working in Edit mode. An account can have several editors.

Edit mode and Live mode — Edit mode is where editors change an app; Live mode shows the app as its users see it.

External member — someone who logs in to use an app but can't change it, such as a client or one of their employees. Each external member has a role.

Grid — a table of records on a screen, which users can search, sort, filter and, if allowed, edit.

Media field — a field that stores files: documents, images, videos. AI agents and AI blocks can read the files in it.

Quick action — a ready-made set of fields, screens and buttons that adds a feature to a grid in one step, such as sending an email or uploading a file.

Record — one row in a table: one contract, one client, one invoice.

Relationship — a link between two tables, such as "a contract has many clauses". Relationships let screens, variables and templates reach related data.

Role — a group of users who see the same screens and data, such as Client or Reviewer.

Screen — a page in your app, holding grids, components, buttons and text.

Screen input — the record a screen is about. Setting it lets the screen show, edit and use that record's data.

Table — where an app stores one kind of record, such as Contracts or Clauses.

Template — a PDF template, email template or AI agent. Each is stored on a table and used for each of its records.

Variable — a placeholder for a value from your data, such as Contract.Counterparty or USER.username, used in labels, conditions, prompts and templates.

Create your first app

You can start an app from a description, from scratch, from a spreadsheet, or from a template.

From a description

1. In the Applications list, select New app. [CHECK: the old guide calls this page the Dashboard; use one name throughout]
2. Enter a name and describe the app: the records it manages, how they relate, who logs in and what they can do, and what the app sends or generates.
3. Select Generate. [CHECK: the old guide refers to "the magenta arrow"; use the control's name] nxr.ai proposes a data model as a diagram of tables and relationships.
4. Change the description until the model looks right, then select Generate to build the app. nxr.ai creates the tables, roles and screens.
5. Open the screens from the screen list to see what was built, then select Live mode to try the app as a user.

A good description names the records and how they relate. This one built the Mini CRM template:

This app will manage customers with their addresses and contacts. Each customer
can be sent multiple offers. Each offer has a status and contains multiple
products. A product can be added to multiple offers. Customers can log in and
see their open offers, and they receive emails when a new offer is created.

[VIDEO: first-app] One to two minutes, captions instead of narration: entering a description, reviewing the proposed data model, generating the app, and trying it in Live mode.

From scratch

1. Select New app, enter a name and, optionally, a description.
2. Select I prefer to build manually. nxr.ai creates an empty Home screen.
3. Create your tables first, then your screens. See Building apps.

From a spreadsheet

Create an app from scratch, then import an Excel file: each sheet becomes a table. See Import and export data.

From a template

See Start from a template.

What to expect from AI generation

AI generation gives you a working first version quickly, and shows what the platform can do. Expect to refine it: AI handles simple apps well and complex ones partly. A practical way to work:

1. Generate a first version from a description.
2. Add features with AI commands.
3. Add common functions — uploads, emails, PDFs — with Quick actions.
4. Finish the details by hand.

Build your first document workflow

In this tutorial, you build a contract review app: upload contracts, extract their key terms and clauses with AI, have a reviewer check them, and generate a one-page summary of each approved contract. It takes about 20 minutes. [CHECK: time]

Before you start, download the sample contracts. [TBD: link to three fictional contracts, three to five pages each] Practise with fictional documents, not real client contracts.

1. Build the workflow with one command

Create a new app with I prefer to build manually, then select the AI button at the bottom right of the editor [CHECK: label] and enter:

Create a pipeline for reviewing contracts. I'll upload each contract as a PDF.
Extract the counterparty, effective date, renewal date, notice period and
payment terms. Extract each clause about liability, termination, renewal,
confidentiality and payment into a separate table, with the page and the exact
quote it came from. Let a reviewer check and approve each clause, then approve
the contract. Generate a one-page summary PDF for each approved contract, with
a short AI-written overview at the top.

nxr.ai builds: [CHECK: run this exact prompt and replace the list below with what it actually builds]

• a Contracts table with a Media field for the PDF, and a Clauses table linked to it;
• screens for uploading contracts, reviewing clauses and viewing approved contracts;
• two AI agents, one extracting each contract's terms and one its clauses;
• a PDF template for the summary, with an AI block that writes the overview.

2. Upload a contract

Select Live mode, open the upload screen and add the first sample contract. Then run the extraction from the contract's row. [CHECK: button label] When it finishes, open the contract: its key terms are filled in, and its clauses are listed underneath.

3. Check the results

Compare a few extracted values with the document. [CHECK: whether the generated screen shows the document next to the data; if not, add a Document preview component] Every quote should appear word for word on the page given. This check is the point of a document workflow: AI does the reading, and people confirm the result.

4. Review and approve

Open the review screen. Correct anything that's wrong, approve each clause, then approve the contract.

5. Generate the summary

Select the button that generates the summary PDF. [CHECK: label] The overview at the top is drafted by AI; everything else comes straight from the approved data.

6. Refine it with smaller commands

Go back to Edit mode and try these, one at a time:

Add a risk level of low, medium or high to each clause, with a one-sentence
reason, rated by AI against these standard positions: liability capped at 12
months' fees; termination with at least 60 days' notice; no automatic renewal.

Show high-risk clauses first on the review screen.

Add a button that emails the summary PDF to the contract owner.

Each command changes the existing app. Check the result after each one, and fix the details by hand where needed.

What you built. A document workflow. Here, the summary's structure is fixed by its template; for longer documents, an AI agent first proposes an outline for people to review. How document workflows work explains all five stages.

[VIDEO: document-workflow] One to two minutes, captions instead of narration: the "Create a pipeline" command, uploading a sample contract, checking the extracted clauses, approving them, and generating the summary PDF. The homepage uses the same video.

Start from a template

App templates are ready-made apps you can use as they are or change. In the Applications list, select New app from template [CHECK: label] and choose one.

The Client portal and Training videos templates were generated from these descriptions, which are good examples of what to write:

Manage my clients (companies) with their addresses and contacts. My employees
can log in to manage their clients. Clients can log in to view projects and
tasks.

Manage a list of videos that can be assigned to customers. Manage a list of
customers with each customer having multiple employees. Employees can watch
the training videos and receive a training certificate when done.

How document workflows work

Long documents that have to be right — audit reports, contract reviews, questionnaire responses, technical manuals — are hard to produce with a single AI prompt. The result is hard to check, inconsistent from section to section, and difficult to fix one part at a time.

A document workflow breaks the work into records your team can see and control. It has five stages:

1. Extract. People upload source documents through a form. An AI agent reads each file and writes what matters — requirements, clauses, questions — into records, each with the page and quote it came from.
2. Structure. For longer documents, another AI agent proposes the outline as records: the sections, their order, and which extracted items each one covers.
3. Review. Your team checks the items and the outline in ordinary grids and forms — correcting, reordering and approving — before anything is written.
4. Draft. AI writes each section from its items and your reference material, either inside the document as it's generated, or into the records first so each section can be reviewed. See Draft the content.
5. Generate. A PDF template loops through the approved sections and produces the finished document.

[DIAGRAM: document-workflow] Five stages left to right — Extract (source document → records), Structure (records → outline), Review (people approve), Draft (AI writes sections), Generate (PDF) — with a person icon at the review stage. Alt text: "The five stages of a document workflow: extract, structure, review, draft and generate, with people approving the work before drafting."

Because every stage is stored as data, you can trace each section back to the items it covers and each item back to its source, require approval before the next stage starts, and reuse the workflow for the next document or the next client.

A document workflow is an ordinary nxr.ai app made of tables, screens, actions and templates, so everything in Building apps and Templates applies to it. You can build one with a single AI command, by hand, or both.

Create a workflow with an AI command

The fastest way to build a document workflow is to describe it. In Edit mode, open the AI command box and start with "Create a pipeline for…". nxr.ai builds the tables, upload forms, review screens, AI agents and templates with AI blocks, and links them into a working app. You can then refine it with smaller commands or by hand.

[CHECK: Does the command always create a new app, or can it extend the one that's open? Roughly how long does it take, and does it summarise what it built? Say so here.]

A good command covers five things:

Create a pipeline for [the document you produce].
I'll upload [the source documents].
Extract [the items you need], with [the details of each, such as page and quote].
[How the output is organised, if it's more than a fixed layout.]
Let [who] review and approve [what].
Generate [the output] as a PDF.

Examples

Create a pipeline for compliance gap reports. I'll upload a standard as a PDF.
Extract each control with its ID, title and requirement text. Let an auditor
attach evidence and set each control's status to met, partly met or not met.
Generate a gap report PDF with one section per category and a summary of the
gaps on the first page.

Create a pipeline for answering security questionnaires. I'll upload a
questionnaire. Extract each question with its section and number. Draft an
answer to each question from our policy documents, which I'll upload
separately. Let a reviewer approve each answer, and generate the completed
questionnaire as a PDF.

Create a pipeline for writing user manuals from product specifications. I'll
upload a specification. Extract each feature with its description and
settings, propose a chapter outline for me to review, draft each chapter for
non-technical readers, and generate the manual as a PDF.

Tips

• Name the details you need. "Extract each clause" gives you text; "…with its type, page and exact quote" gives you something you can check.
• Say who approves what. Review steps are built only if you ask for them.
• Start small. Build the core workflow first, then add features with follow-up commands.
• Test with a real document before relying on the workflow, and adjust the AI agents' prompts if the extraction is too coarse or too fine.

Upload source documents

Uploads are built from standard parts: a Media field stores the file, and a File upload component on a form lets people add it.

1. Add a Media field to the table that represents the document — for example, File on Contracts.
2. On a screen whose input is that table, type / on an empty line, select Component and choose the Media field.
3. Add a button with a Save form action so the upload is stored.

Alternatively, apply the Upload file quick action to a grid: it creates the field, the screen and the button in one step.

To show the document next to the extracted data, add a Document preview component for the same field to the review screen.

[CHECK: which file types AI agents and AI blocks can read — PDF, Word, scanned PDFs — and any size or page limits. Add them here.]

Extract information with AI agents

An AI agent reads a record's data — including the files in its Media fields — follows the prompt you give it, and writes the result back into records. In a document workflow, it turns an uploaded document into items people can review.

1. Create an AI agent on the table that holds the document, such as Contracts.
2. Write the prompt. Type / to insert variables, including the Media field, so the agent reads the file.
3. Choose where the result goes: fields on the same record, or new records in a related table such as Clauses.
4. Add a button that runs the agent.

AI agents covers each step in detail.

A prompt for extracting clauses might read:

Read the contract in Contract.File. Find every clause about liability,
termination, renewal, confidentiality or payment. For each one, return:
- type: liability, termination, renewal, confidentiality or payment
- heading: the clause heading as written
- text: the full clause, word for word
- page: the page where the clause starts
- quote: its first sentence, word for word
Don't summarise or merge clauses. If there's no clause of a type, return
nothing for it.

Contract.File is a variable, inserted with /. For more advice, see Writing effective prompts.

Review and approve

Review is built from ordinary parts:

• A status field on the items, such as a Single select field with the options Pending, Approved and Rejected.
• A review screen with a grid of items filtered to Pending, and editable columns so reviewers can correct values in place.
• Buttons that set the status, using the Set field custom action — an Approve row button, for example.
• Visibility conditions, so only reviewers see the review screen and its buttons.
• A status on the parent record, such as the contract, which a reviewer sets once all its items are checked. Use it to hide the button for the next stage until review is complete.

[CHECK: Can a button be enabled only when all related items are approved? Conditions compare fields and combine with AND; if they can't check related records, the parent status above is the way to do it.]

Draft the content

There are two ways to have AI write a document's text. Choose by how closely each section needs checking.

In the document, with AI blocks. Put an AI block inside a loop in the PDF template. Each time the document is generated, the block drafts every section from its data. This is quick to set up and suits documents reviewed as a whole, such as summaries. Use an editable preview so people can correct the result before it's sent.

In the records, with an AI agent. Add a draft field to each section record, and an AI agent that writes into it. Reviewers read, edit and approve each section in a grid, and can rerun the agent for one section without touching the rest. The template then prints the approved text, so the same data always produces the same document. Use this for long documents where every section must be right.

The "Create a pipeline" command drafts in the document, with AI blocks. To review sections one by one, switch to the second approach by hand or with a follow-up command. [CHECK: confirm the command's default, and whether a follow-up command can make this switch]

Generate the finished document

The finished document is a PDF template on the parent record — the contract, the report, the questionnaire — with a FOR loop over its sections.

1. Add a PDF template field to the parent table, or apply the Generate PDF quick action to its grid.
2. In the template, add a FOR loop over the related sections, and place each section's title and text inside it. See Conditions and loops.
3. Generate the PDF with a button, or show it on a screen with a PDF template component.

For templates with AI blocks, avoid the component's Refresh in this screen option: the AI would redraft the document every time someone opened the screen. Generate it with a button, or use Editable preview. [CHECK: whether AI blocks rerun on every refresh]

Good practice for document workflows

• Make every item traceable. Ask agents for the page and an exact quote, and show the source file next to the items with a Document preview component.
• Ask AI to flag gaps rather than guess. Tell agents and blocks to write [MISSING: what's missing] when the source doesn't support an answer, then filter for it on the review screen.
• Get the granularity right. Test extraction on one document first. If you get hundreds of tiny items, or items that bundle several requirements, say in the prompt what counts as one item: "one item per numbered requirement".
• Keep a person between AI and the outside world. Nothing AI writes should reach a client unreviewed.
• Test with your own documents. Real documents vary more than samples, so try several before you rely on a workflow.

The editor

You build apps in Edit mode and use them in Live mode. Switch between the two at any time with the buttons at the top right. Only editors can use Edit mode.

[IMAGE: editor-overview.png] The editor in Edit mode, full window, with numbered callouts 1–5 matching the list below. Use the contract review app. Alt text: "The nxr.ai editor: the screen list on the left, the screen being edited in the centre, the Properties inspector on the right, the toolbar above, and the AI button at the bottom right."

1. Screen list — your app's screens, grouped by the buttons that link them, with role visibility for each.
2. Main editing area — the selected screen. Edit it like a text document: click to type, and type / to insert things.
3. Properties inspector — the settings of whatever you've selected: a screen, a grid, a column, a button.
4. Toolbar — Users and roles, the Data overview, Messages, and the switch between Edit mode and Live mode. [CHECK: labels, and what Messages is for]
5. AI button — opens the AI command box. See AI commands.

The / menu. On an empty line, type / to insert a grid, a form component, a button or text. In a text field — a label, a template, a condition, a prompt — / opens autocomplete for variables. [CHECK: the old guide says to select "the second icon" to list variables]

To return to the list of your apps, select Applications in the breadcrumb at the top left.

Tables and relationships

Define your data before you build screens. nxr.ai uses tables and relationships to generate screens, related grids and variables, so getting them right first saves rework.

Open the Data overview from the toolbar to edit the app's description and its tables. [CHECK: label] A diagram of your tables and relationships updates as you work.

Tables and columns

• To create a table, select Create new table.
• To add a column, open the menu next to a column's name and select New column, or select a column and press Enter. Press Enter again to add a new table.
• To change a column's type, select its current type.

Data types: Integer, Decimal, Text, Boolean, Date, Datetime, Single select, Multi select, Schedule frequency, Media, PDF template, Email template, AI agent, and Relationship. [CHECK: the current list; whether AI agent is created as a field type like PDF and email templates; what Schedule frequency does]

Relationships. Add a column of type Relationship with… to the table on the "many" side, and choose the other table: the Clauses table gets a Contract column. Check that the description reads the right way round: "A Contract has many Clauses". [CHECK]

Default values: auto-increment; the current year, date, or date and time; the current user; or a custom value such as INVOICE-{{YEAR}}-{{AUTOINC}}.

Reference columns. Choose one or more columns to identify a record wherever it appears in a dropdown — an invoice's number and date, for example, rather than its ID.

Login data. From a column's menu, you can set a table As login data for the role of the same name. nxr.ai adds a username column, and each record becomes a login. See Roles and login tables.

Two things nxr.ai doesn't yet update for you:

• Columns you add by hand aren't added to screens generated earlier. Add components for them yourself.
• Renaming a column doesn't update the variables that use it in labels, templates, prompts, conditions and API calls. Update them by hand.

Import and export data

Import from Excel

1. In Edit mode, open the tables in the Data overview and select Import an Excel.
2. Choose the file and select Upload. A summary shows what will be imported.

Each sheet becomes a table, with column names taken from the first row. If a table with the same name exists, the rows are added to it and any new columns are created. Every column is imported as text, so set the right types afterwards. Relationships aren't imported.

Export to Excel. Select Export to Excel in the same place to download all of the app's data. The app's screens and logic aren't included.

Export a grid. Add a grid button that exports the grid to an Excel file, or one that emails it: on the screen the button opens, the variable SOURCE_GRID_AS_XLSX attaches the grid's contents to an email. Either way, the grid's current filters apply.

Screens

Screens are the pages of your app. They hold grids, form components, buttons and text.

• To add a screen, select Add new screen in the screen list, then type its title.
• New screens are visible only to the Administrator role. To change that, open the menu next to the screen's name and switch roles on or off.
• For more precise visibility, select the screen title and add conditions under Show when in the Properties inspector. See Visibility and filtering.
• Other screen settings let you hide the title, and open the screen full size or in a sidebar. [CHECK]

The screen list groups screens by the buttons that link them. A screen reachable from several places appears under only one of them.

Screen input

A screen's input is the record it's about. The input of an Edit contract screen is a record from the Contracts table. Once it's set, the screen can:

• show forms that edit that contract;
• show grids of related records, such as its clauses;
• use variables such as Contract.Counterparty in labels and templates;
• send emails, generate documents and run AI agents for that contract.

[DIAGRAM: screen-input] A Contracts grid with an Open button on one row → arrow labelled "passes the contract" → an Edit contract screen whose input is that contract, showing its form and a grid of its clauses. Alt text: "A row button passes its record to the next screen, which uses it as the screen input."

To set it, select Screen input next to the screen title, then choose a table in the Properties inspector.

How the record arrives. The screen that leads here must pass a record of that type:

• A row button in a grid passes its row: Open on a contract's row passes that contract.
• A screen with an input passes it on through its buttons.
• A button that creates a record passes the new record.
• Related records are resolved for you: a screen about a clause can open a screen about its contract.

Top-level screens, such as a list of all contracts, usually don't need an input.

Data grids

A grid shows a table's records on a screen, and lets users search, sort, filter and edit them.

Add a grid. On an empty line, type /, select Grid and choose a table. The new grid shows up to five columns and is read-only.

[IMAGE: grid-header.png] A crop of a grid's header, with callouts for the filter control, the editing setting, the layout, View data and Setup. Alt text: "A grid header with its controls: filter, editing setting, layout, view data, and the Setup menu." [CHECK: control labels]

Columns

• To add a column, select a column and then the + icon next to it. To rename one, edit its header.
• Select Setup at the top right of the grid to show or hide columns, including columns from related tables, which show the relationship's name above the column name.

Sorting. Use the control next to a column's name. Sorting in Edit mode sets the default order for all users.

Filtering. Select the filter control in the grid header, then + in the Properties inspector. Choose a column — visible, hidden or related — an operator such as is, is not, in, less than or greater than, and a value or variable. See Visibility and filtering.

Editing. The grid's editing setting, in its header, has three options: [CHECK: labels — the old guide uses both "Edit mode: edit in form" and "Editing: in screen"; ideally rename the setting so it can't be confused with the app's Edit mode]

• View only — no editing. New grids start like this.
• In grid — users edit values directly in the grid, and changes save automatically. Choose which columns are editable by selecting a column and switching Editable in the Properties inspector.
• In screen — nxr.ai generates screens for creating, editing and deleting records, including related records such as a contract's clauses, and adds buttons to the grid to open them. If you later choose another option, those screens remain but are no longer linked; delete them by hand.

Validation. Select a column and choose an option under Validate. A comma-separated list turns the column into a dropdown. For a dropdown whose values come from another table, use the Dropdown field quick action.

Buttons. Select Setup, then Add row button or Add grid button. Select the new button to set its name, its actions, an optional icon, and conditions. A row button whose conditions aren't met is shown disabled on that row. See Buttons and actions.

Form components

Components show and edit a single field of the screen's input record.

[CHECK: the component list and names in the current version]

Add a component. On a screen with an input, type / on an empty line, select Component and choose the field. Grids set to edit In screen generate their forms for you.

Save the form. Changes are saved by a button with a form action, such as Save or Create. Every screen with a form needs one. See Buttons and actions.

Buttons and actions

Buttons move people between screens and make things happen: saving a record, running an AI agent, generating a document.

• Screen buttons: type / on an empty line and select Button. Choose a target screen, or leave it empty.
• Grid buttons: select Setup in the grid header, then Add row button or Add grid button.

Select a button to set its actions in the Properties inspector. There are three kinds.

Form actions create, save or delete a record: the screen's input record, or the row the button is on. A button has one form action; choosing another replaces it.

Custom actions. A button can have several: [CHECK: whether they run in the order listed]

• create a record;
• set a field on the current record or a related one;
• run an AI agent [CHECK: action name];
• generate a PDF from a template;
• send an email from a template;
• call an external API;
• export the grid to Excel;
• reset the password of a login record.

To remove a custom action, select the minus sign next to it.

Navigation actions open another screen, existing or new, or refresh the current one. A button has one navigation action; choosing another replaces it.

Variables

Variables insert values from your data into labels, titles, templates, prompts, conditions and action settings.

• Type / in a supported field to open autocomplete, then choose a variable.
• Variables come from the screen's input record, so a screen needs an input before they're available. The exception is USER, the person who's logged in.
• Related records are reached through relationships: from a clause, Clause.Contract.Counterparty.
• USER gives access to the logged-in user's record and its relationships, for example USER.username, USER.Client.Name or USER.Client.Address.Street.
• In templates, loops give access to each related record in turn. See Conditions and loops.

Visibility and filtering

Two separate tools control what people see.

Visibility decides whether a screen, grid, component or button appears.

• For a screen, open the menu next to its name in the screen list and switch roles on or off.
• For anything else, select it and add conditions under Show when in the Properties inspector. Conditions can use the record's fields, related fields and USER.
• A row button whose conditions aren't met appears disabled on that row.

Filtering decides which records a grid shows. Add filter conditions to the grid, as described in Data grids.

[IMAGE: conditions-panel.png] A crop of the Properties inspector with two Show when conditions, such as "USER.role in Reviewer" and "Contract.Status is In review". Alt text: "Show when conditions in the Properties inspector, each made of a field, an operator and a value."

When there are several conditions, all must be true: nxr.ai combines them with AND. OR isn't available yet.

Hiding a screen doesn't filter its data. A grid shows every record in its table unless it's filtered. For external members, filter grids by the logged-in user — for example, show only offers where Offer.Customer is USER.Customer — so each client sees only their own records. See Security.

Quick actions

Quick actions add common features to a grid in one step, creating the fields, screens and buttons you'd otherwise set up by hand.

1. In a grid, select Setup, then Quick actions. [CHECK: renamed from "Solutions" in the product]
2. Choose one. A summary lists each change it will make; nothing changes yet.
3. Select Apply, then adjust the result as needed.

How templates work

Templates turn your data into output. There are three kinds:

• PDF templates produce documents.
• Email templates produce emails.
• AI agents send your data to AI and write the result back into records.

A template is a field on a table. It's stored once, as a blueprint for the table, and used for each record: an Invoice table's PDF template produces a different PDF for each invoice, filled with that invoice's data.

Inside a template, type / to insert variables from the record and its related records, conditions, loops and AI blocks. [CHECK: whether AI blocks are inserted through the / menu] When you create a template, nxr.ai suggests sample content using your table's fields, which is a quick way to see what data is available.

Templates in this section are not the same as app templates, which are ready-made apps. See Start from a template.

PDF templates

The quickest way to set up a PDF template is the Generate PDF quick action on a grid. It adds a PDF template field, a screen with a PDF template component, and a row button that opens it.

The PDF template component has three options:

• Refresh in this screen — the PDF is generated again each time someone opens the screen.
• Editable preview — the PDF is generated the first time the screen is opened, and users can switch between Edit and Preview to change it.
• None — the component shows a PDF generated earlier, for example by a button.

Generated PDFs are stored with each record.

Email templates

Use the Send email quick action on a grid to add an email template, a screen that shows it, and a row button that opens it.

The email template component has three options:

• Read-only preview — users send the email as it is.
• Editable preview — users can change the text, subject and recipients, and add attachments before sending.
• Hidden — users don't see the email; editors see it in Edit mode.

Attachments can be added by hand, or as variables pointing to PDF template or Media fields, so a generated PDF is attached automatically.

To add CC and reply-to addresses to your apps' emails, see Account settings.

Conditions and loops

Templates support conditional content (IF) and repeated content (FOR), so a document's content and length can follow your data.

IF shows content only when a condition is true — for example, a section that appears only when a field has a value.

1. In Edit mode, click where the condition should go and type /.
2. Choose {% if condition %}.
3. In the Properties inspector, choose the column, the operator and the value to compare it with.

Conditions can use variables, including related fields.

FOR repeats content for each related record. A project has many tasks, for example: a FOR loop lists them, one row per task.

A loop reads like this: for element0 in Project.Task. Project.Task is the collection of the project's tasks; element0 is the current task. Inside the loop, use variables such as element0.Task name and element0.Status. Everything between the FOR and endfor markers repeats for each task.

1. Click where the loop should go and type /.
2. Choose {% for element in table %}.
3. In the Properties inspector, choose the related table to loop through.

Loops are ideal for tables with a variable number of rows: put the variables in a table row inside the loop, and the row repeats for each record. IF and FOR can be combined, and loops can contain AI blocks.

AI blocks

An AI block is a template element that combines prompt text with variables. When the document is generated, the AI's answer appears in the block's place. Variables can include related records and the files in Media fields, which the AI reads.

1. In a template, click where the text should go, type / and choose AI block. [CHECK: menu label; and whether AI blocks work in email templates as well as PDF templates]
2. Write the prompt, inserting variables with /.
3. Generate the document to see the result.

Inside a FOR loop, the block runs once for each record. This is how nxr.ai drafts long documents section by section:

Write the section "element0.Title" in 150 to 250 words, using only these
requirements: element0.Requirements. Use a formal tone. If the requirements
don't give you enough to go on, write [MISSING: what's missing] instead of
guessing.

[IMAGE: template-loop-ai-block.png] A crop of a PDF template in Edit mode: a FOR loop over sections, containing the section title as a variable and an AI block whose prompt includes variables, with the AI block's settings in the Properties inspector. Alt text: "A PDF template with a loop over sections; inside the loop, an AI block drafts each section from its variables."

Things to know

• AI blocks run each time the document is generated, and each run may word things differently. For text that must stay fixed once approved, draft it into records with an AI agent instead. See Draft the content.
• Each block is a request to the AI, so a loop over 50 sections makes 50 requests, and long documents take longer to generate. [CHECK: time limits, and AI usage limits on hosted plans]
• Ask for a length and format, so the text fits your layout.

AI agents

An AI agent is a template that sends a prompt, filled with your app's data, to AI, and writes the result back into records. Use agents to:

• extract items from an uploaded document into a table;
• propose a document's outline as records;
• classify or assess records, such as setting a risk level with a reason;
• draft text into a field for people to review.

Create an agent

1. Add an AI agent to the table it works on. [CHECK: created as a field of type AI agent?]
2. Write the prompt, inserting variables with /. A Media field gives the agent the file itself.
3. Set where the output goes: fields on the same record, or new records in a related table. [TBD: how output is mapped to fields, and how the AI's answer is matched to them]
4. Add a button that runs the agent. See Buttons and actions.

[IMAGE: ai-agent-template.png] A crop of an AI agent in Edit mode: the prompt with variables, including a Media field, and the output settings showing which table and fields it writes to. Alt text: "An AI agent's settings: a prompt that uses variables, and the fields its results are written to."

Run it on one record at a time while you test. Check the results against the source, adjust the prompt, and only then use it on many records.

[TBD: Can an agent run on several records at once? What happens if it times out or fails — is anything written? Are there limits on input size?]

Formatting tips for templates

Most layout problems in generated PDFs come from content pasted from Word and other documents, which brings hidden formatting with it.

• Paste as plain text — Ctrl+Shift+V, or Cmd+Shift+V on a Mac — then format with the template editor's own tools.
• Build tables in the editor instead of pasting them.
• Use the editor's heading styles rather than large bold text, so headings stay consistent.
• Test with long data. Loops and AI blocks can produce more text than you expect, so try a record with many related items.
• Keep images close to their printed size.

[CHECK: whether page breaks, headers and footers are supported; if so, add how to use them here]

Troubleshooting templates

When you leave Edit mode, nxr.ai flags content and syntax problems in your templates. This check is experimental and may not catch everything.

Common causes of problems:

• A renamed column. Variables that used the old name stop working; update them.
• A loop variable outside its loop. element0 exists only between FOR and endfor.
• An unclosed IF or FOR. Each needs its end marker.
• Pasted formatting. Paste the content again as plain text.

If a document looks wrong but no problem is flagged, generate it for a record with complete data. That shows whether the template or the data is at fault.

Where nxr.ai uses AI

The first three help you build apps. AI agents and AI blocks run inside your apps, for your users.

AI commands

AI commands change your app from a description.

1. In Edit mode, select the AI button at the bottom right. [CHECK: label; the old guide calls this feature "inline AI solution search"]
2. Describe the change and send it.
3. Check the result, and adjust it by hand if needed.

Examples

Add a Status field to Offers with the options draft, sent and accepted.

Create a screen where customers see their own open offers.

Add a button to the contract screen that emails the summary PDF to the
contract owner.

To build a complete document workflow in one go, start with "Create a pipeline for…". See Create a workflow with an AI command.

Tips

• Make one change per command. It's easier to check than several at once.
• Use the names in your app — tables, fields and screens, spelled as they are.
• Clone the app before a large change, as a backup. [CHECK: or describe how to undo a command, if that's possible]

AI suggestions

• New tables. When you create a table by hand, nxr.ai suggests columns. Accept or reject each one.
• New templates. A new PDF or email template starts with suggested content that uses your table's fields, such as Product.Name and Product.Price.

To stop suggestions from appearing, switch off AI popups in Account settings. [CHECK: what the AI popups setting covers]

Writing effective prompts

This advice applies to AI agents and AI blocks.

1. State the task in one sentence. "Extract every clause about liability" works better than "Analyse this contract".
2. Give it only the data it needs, inserted as variables. Less input gives faster, more focused results.
3. Say what to return, and in what form — the fields, the length, the tone, the language.
4. Ask for evidence: the page and an exact quote for anything taken from a document.
5. Say what to do when information is missing, for example: "write [MISSING: what's missing] instead of guessing."
6. Give criteria for judgements. "Rate the risk" invites a guess; "high if liability is uncapped" gives a rule.
7. Test on several records, including an awkward one, before relying on the prompt.

Before: "Summarise the contract."

After: "Summarise the contract in Contract.File in three sentences for a business reader: who the parties are, what is being bought, and the renewal terms. Use only the contract. If the renewal terms aren't stated, say so."

Your data and AI

nxr.ai sends data to AI only when an AI feature runs: when you generate or change an app with AI, when you receive AI suggestions, or when an AI agent or AI block in your app runs.

What is sent. The prompt, your app's structure — table and field names — and the data the feature references: the variables in an agent's or block's prompt, including files in Media fields. Nothing else in your app is sent.

Who receives it. On the hosted service, AI requests go to Anthropic through the Claude API. Every provider that processes data for us is listed in our Data Processing Agreement.

Training. Your data isn't used to train AI models, whether ours or Anthropic's. Your app's structure, without any of its data, may be used to improve AI suggestions; you can opt out, as described in our Privacy Policy. [CHECK: match the final wording of DPA §8.2 once it's confirmed against Anthropic's current terms]

Keeping data away from AI. AI agents and blocks use only the data referenced in their prompts. To keep a field out of AI processing, don't reference it.

Self-hosted installations. AI features use your own API key, and requests go directly from your server to the AI provider, without passing through nxr.ai. [CHECK: that self-hosted installations send nothing to nxr.ai, such as telemetry or licence checks]

Check what AI writes. AI output can be wrong or incomplete. Review it before you rely on it or send it to anyone; document workflows are built around that review.

Editors and external members

nxr.ai has two kinds of users.

Editors build and change apps in Edit mode. An account can have several editors; your plan sets how many. [TBD: how to invite an editor; whether editors can be limited to particular apps; whether the account owner has extra rights, such as billing]

External members log in to use finished apps — your clients, their employees, or colleagues who use the app without changing it. Each belongs to a role, which decides what they see. They sign in with a username and password. [CHECK: whether external members can use two-factor authentication]

Roles and login tables

Roles group external members who should see the same things, such as Client, Employee or Reviewer. You use roles in visibility conditions, grid filters, button actions and templates.

Create a role

1. In Edit mode, open Users and roles from the toolbar. [CHECK: label]
2. Under User roles, select Add and name the role. Each role gets a color, which marks its visibility in the screen list.

Each role needs a login table: a table set As login data for the role of the same name. nxr.ai adds a username column, and each record in the table becomes a login for that role. For a Client role, the Client table holds your clients' logins.

The quickest way to set this up is Create screen to manage role, at the top right of Users and roles. It creates the login table and a screen for managing the role's users.

Every app starts with an Administrator role, used by editors. [CHECK]

Inviting external members

To give someone access, add a record to their role's login table — usually through the screen created by Create screen to manage role — and send an invitation.

• Invite email sends the new user a temporary password. You can send it, and send it again, at any time. The User invite quick action sets this up on a grid.
• Forgot password email is sent when a user asks for a reset on the sign-in page. It works only for users whose username is an email address.

You can let a role manage other users — employees inviting and managing clients, for example — by giving that role access to the user management screens.

Users can change their own username and password in User Profile, under the icon at the top right.

Password reset

Editors can reset a user's password from the Users overview, or from the grid that manages that role's users. The reset dialog offers two options:

• set a new password and share it with the user yourself;
• email the user about the change.

You can also require users to change their password at their next login, here or for everyone in Account settings. [CHECK]

Users overview

The Users overview lists everyone with access to an app.

Use Search users to find someone.

Account settings

Open your account settings from the icon at the top right, then select your username. Here you can:

• change your username or email address, and reset your password;
• turn on two-factor authentication;
• set the language of your apps — English or German;
• set the date format;
• turn AI popups on or off;
• add CC and reply-to addresses to the emails your apps send.

Managing apps

Select Applications in the breadcrumb at the top left to see all your apps. From there, you can create an app, create one from a template, or clone an existing app.

Cloning is the quickest way to reuse a workflow for another client: build it once, clone it, and adapt the copy. [CHECK: whether a clone copies the data as well as the structure; say which here]

Self-hosting

nxr.ai is open source under the MIT licence. You can run it on your own infrastructure with Docker, with no limits on records, editors, external members or apps. You provide the servers, the storage and an AI provider API key; support comes from the community on GitHub.

[TBD] This section needs your installation details. The parts below are the minimum self-hosters look for.

Requirements. [TBD: Docker and Docker Compose versions; CPU, memory and disk for a small installation; the database; tested operating systems]

Install

# [TBD: replace with the real commands]
git clone [TBD: repository URL]
cd [TBD]
cp .env.example .env    # then edit the settings below
docker compose up -d

Configure

First login. [TBD: how the first editor account is created]

Back up both the database and the file storage; neither can be restored without the other. [TBD: where each is kept in the default setup]

Upgrade. [TBD: the upgrade steps, and whether database migrations run automatically]

Premium features. [CHECK: if any features in this release are under a commercial licence rather than MIT, list them here]

Security

On the hosted service

• Data is stored on Amazon Web Services, in the EU. [CHECK: region]
• Each app has its own data and users, separate from other apps.
• Editors can protect their accounts with two-factor authentication.
• Data is encrypted in transit and at rest. [CHECK: matches DPA Annex II]
• The providers that process data for us are listed in our Data Processing Agreement.

Your part

• Give editor access sparingly, and remove it when people leave.
• Use roles and visibility conditions to show each user only what they need.
• Filter grids for external members with USER variables, so clients see only their own records. Hiding a screen doesn't filter its data.
• Review AI output before it leaves your organisation.

[CHECK: whether grid filters and visibility conditions are enforced on the server, not only in the browser. If they're browser-only, say so here, because it changes how customers must design access.]

Frequently asked questions

Who owns my data? You do. We never sell your data or use it to train AI models. To run the hosted service we use a small number of providers — for hosting, email delivery and AI — listed in our Data Processing Agreement.

Where is my data stored? On the hosted service, in the European Union, on Amazon Web Services. [CHECK: region] On a self-hosted installation, wherever you run it.

What is sent to AI? Only what an AI feature needs while it runs. See Your data and AI.

Can I rely on AI-generated content? Treat it as a draft. AI is good at extracting, structuring and drafting, but it can be wrong, so have someone review its output before it's used. The review step in a document workflow exists for exactly that.

Can I run nxr.ai on my own servers? Yes. nxr.ai is open source under the MIT licence and installs with Docker. See Self-hosting.

Can several people build the same app? Yes. An account can have several editors; your plan sets how many.

What's the difference between an editor and an external member? Editors build and change apps. External members log in to use finished apps — your clients, for example, or their employees — and see only what their role allows.

Can I export my data? Yes. You can export all of an app's data to Excel from the Data overview, and add buttons that export a grid. An app's screens and logic can't be exported yet; to reuse an app, clone it.

Which languages can apps use? English and German.

How do I get help? See Contact support.

Known limitations

• Several conditions combine with AND only; OR isn't available.
• Columns added by hand aren't added to screens generated earlier.
• Renaming a column doesn't update the variables that use it.
• Excel import creates one table per sheet, imports every column as text, and doesn't import relationships.
• Excel export includes data only, not the app's screens or logic.
• Switching a grid away from editing In screen leaves its generated screens unlinked; delete them by hand.
• Forgot-password emails need an email address as the username.
• Template problem detection is experimental.
• Apps are available in English and German.
• The screen list shows each screen under one parent, even when several screens link to it.
• AI blocks draft their text again each time a document is generated.

[TBD: limits on AI input — file size, page count, scanned documents]

Troubleshooting

Contact support

• Paid plans: in any app, open the menu at the top right and select Contact support, or email support@nxr.ai. [CHECK: address]
• Self-hosted: open an issue or start a discussion on GitHub. [TBD: repository link]