# Create apps without code

> Everything you do with apps in the nexxus interface, no code needed: start a new document of an app, install an app from a .nxa file, let the AI Assistant create a new app, and publish a new version with its changelog.

:::tip[Writing the app's code yourself?]
This page stays in the nexxus interface. If you program an app by hand, the package format, the sandbox and the message protocol are in the [developer reference](/apps/build/).
:::

"Creating an app" covers four different jobs, and most people only ever need the first one:

| You want to | You need | Section |
|---|---|---|
| Start a new board, a new set of notes, a new deck | An app that is already installed | [Create a document](#create-a-document-of-an-installed-app) |
| Add an app someone gave you as a file | The `.nxa` file | [Install an app from a .nxa file](#install-an-app-from-a-nxa-file) |
| Get a tool that does not exist yet | A clear idea of what it should hold | [Let the AI Assistant create a new app](#let-the-ai-assistant-create-a-new-app) |
| Bring an installed app up to date | The new `.nxa` file, and to own the app or be an administrator | [Publish a new version](#publish-a-new-version) |

In this guide, Jonas Weber from the project team of Brandt & Söhne does all four: he starts a Kanban board for a trade fair, installs the example app from the help, has the AI Assistant build a small app for visit reports, and later publishes the second version of that app.

## Before you start

- **The app list.** You open it with <MenuPath to="Start > Apps" />. If the entry is missing, your role lacks the permission <Ui>Apps</Ui> with <Ui>Read (management)</Ui>, or an administrator switched the area <Ui>Apps & workspace</Ui> off. The roles the setup wizard creates don't include this permission, so an administrator adds it in the role editor. See [Roles](/setup/roles/).
- **A folder you may write to.** An app document is a file in <Ui>Files</Ui>. You need the right to create files in the folder you pick.
- **For the AI Assistant.** The connector <Ui>Apps</Ui> is active in new chats by default. Its action <Ui>List apps</Ui> lets the AI Assistant read which apps exist; <Ui>Build and change apps</Ui> lets it create documents and install apps. An administrator can switch either action off, see [Connectors](/plugins/overview/).
- **For installing.** Anyone who can open the app list can install an app. What you install as a normal user becomes your own app. What an administrator installs is available to the whole tenant.

## Create a document of an installed app

Every app works the same way: a new document is a new file. There are four places to start one, and all four lead to the same document page.

<Tabs>
<TabItem label="From the app list">

<Steps>

1. Open <MenuPath to="Start > Apps" />.

   <Screenshot src={shot_apps_create_list} url="/dms-apps" alt={"The app list as Jonas Weber sees it, with two own apps"} caption={"Your own apps are marked as such, and only they carry the bin icon for you. The buttons at the bottom import an app or open the help."} />

2. Pick the app. The built-in **Kanban board** and **Markdown editor** sit in the catalog with the badge <Ui>Active</Ui>. Apps your tenant installed are under <Ui>My apps</Ui>.

3. Click <Ui>Create & open</Ui> on the app's card.

4. nexxus asks <Ui>Where should the document go?</Ui> Pick a folder, or create one with <Ui>New folder in the chosen place</Ui>, and click <Ui>Create here</Ui>.

   <Screenshot src={shot_apps_create_folder_picker} url="/dms-apps" alt={"The folder picker before a new board is created in Messe 2026"} caption={"nexxus asks where the new document should go."} />

5. The new document opens full screen. Jonas's board already has the columns `To-do`, `In Arbeit` and `Fertig` and a first card.

</Steps>

</TabItem>
<TabItem label="From Files">

<Steps>

1. Open the folder in <MenuPath to="Documents > Files" /> where the document belongs.

2. Click <Ui>New</Ui>. Below the document types, the section <Ui>New app</Ui> lists every app: <Ui>Kanban-Board</Ui>, <Ui>Markdown-Editor</Ui> and each installed app by its name.

   <Screenshot src={shot_apps_create_files_new} url="/dokumente?ordner=<id>" alt={"The New menu in Files with the section for apps"} caption={"Every installed app can be started from the New menu, in the folder that is open."} />

3. Click the app. nexxus creates the document in the open folder, or in <Ui>My files</Ui> if you may not write there, and opens it full screen.

</Steps>

</TabItem>
<TabItem label="From the app's page">

<Steps>

1. Open <MenuPath to="Start > Apps" /> and click the app's card under <Ui>My apps</Ui>. The app's page opens.

2. Click <Ui>New document</Ui> at the bottom of the page.

3. Choose the folder as described for the app list, and click <Ui>Create here</Ui>.

</Steps>

</TabItem>
<TabItem label="With the AI Assistant">

<Steps>

1. Open a chat with the AI Assistant and say what you need: "Leg im Ordner Messe 2026 ein Kanban-Board an, mit einer Karte für jeden dieser Punkte: Standbau, Prospekte drucken, Hotel buchen."

2. The AI Assistant looks up which apps exist and what their documents look like, creates the board with the cards filled in, and opens it for you.

3. If the AI Assistant answers that it may not create documents, the action <Ui>Build and change apps</Ui> of the connector is switched off for your tenant.

</Steps>

</TabItem>
</Tabs>

### Name it and start working

At the top of the document page, click the title and type a new one. nexxus stores it inside the document and in the file name, so a board titled "Messe 2026" is saved as `Messe 2026.board.nxd`.

There is no save button. Next to the title the page shows how far saving has got, ending with <Ui>Saved</Ui>. Each change is stored about one and a half seconds after you make it. A version for the document's history is created when you leave the document, or after ten minutes without changes.

<Screenshot src={shot_apps_create_document_page} url="/dokumente/detail/<id>" alt={"The Kanban board Messe 2026 on its document page"} caption={"The app runs on the document page. Above it: the tabs of other boards and full screen."} />

The bar above the app holds what belongs to the app: its own menus (an app can add entries to <Ui>File</Ui> or bring menus of its own), the tabs of other documents of the same app if the app supports tabs, and <Ui>Full screen</Ui>. <Ui>Share</Ui> at the top of the page invites colleagues. They edit the same document live.

### What a new document contains

| App | New title | Starting content |
|---|---|---|
| Kanban board | `Neues Board` | Columns `To-do`, `In Arbeit`, `Fertig`, one card `Erste Aufgabe` |
| Markdown editor | `Neue Notiz` | A heading and two example bullet points |
| Installed apps | The app's name | Whatever the app declares as its starting content, often empty |

A new app document starts with the status <Ui>Draft</Ui>. You change the status like for any other file.

## Install an app from a .nxa file

An app arrives as one file ending in `.nxa`. A colleague may have built it, or you downloaded the example from the help. Installing takes one click, and nexxus checks the file before anything is stored.

<Steps>

1. Open <MenuPath to="Start > Apps" />.

2. Click <Ui>Import app</Ui> at the bottom right and choose the `.nxa` file. A `.zip` with the same content works too.

3. nexxus checks the package. If something is wrong, the reason appears in red at the top of the page (see [When something goes wrong](#when-something-goes-wrong)).

4. The app appears under <Ui>My apps</Ui>. Its card says <Ui>Imported</Ui> if you are an administrator, or <Ui>Own app</Ui> if you are not, followed by the version, for example `v1`.

   <Screenshot src={shot_apps_create_imported} url="/dms-apps" alt={"The example app right after Jonas Weber imported it"} caption={"An app you import yourself is your own app until an administrator installs it for everyone."} />

5. From now on the app is also listed under <Ui>New</Ui> in Files.

</Steps>

**Own app or tenant app.** When Jonas, who is not an administrator, imports the example app, it becomes his own app: only he and the administrators see it under <Ui>My apps</Ui>, and only they can update or remove it. A document he shares still opens for his colleagues, because the app is served to everyone in the tenant. They cannot create new documents with it until an administrator installs the app for the tenant.

:::tip[Try it with the example app]
On the app list, <Ui>Help</Ui> opens a short explanation of how apps are built. <Ui>Download example app</Ui> saves `hello.nxa`, a working app with one text field. Every download gets its own app ID, so several people can install it to try.
:::

### Install a file with the AI Assistant

If the `.nxa` file is attached to your chat message or lies in Files, ask the AI Assistant: "Installier die angehängte App." It installs the package with the same check and the same rule for own and tenant apps as the button, and tells you where to find the app.

## Let the AI Assistant create a new app

When no app fits, describe the one you need. The AI Assistant writes the two parts of an app, the description file and the screen, and registers them. nexxus checks them exactly like an uploaded package.

<Flow
  steps={[
    { icon: 'message-square-text', title: 'You describe it', text: 'What one document should hold, which fields, what it should look like.' },
    { icon: 'sparkles', title: 'The AI Assistant writes the app', text: 'A manifest with a data schema and a self-contained HTML screen.', tone: 'lavender' },
    { icon: 'shield-check', title: 'nexxus checks', text: 'ID, required fields, schema, size. Errors go back to the AI Assistant to fix.', tone: 'cyan' },
    { icon: 'circle-check-big', title: 'The app is there', text: 'Under My apps, and the AI Assistant can create the first document.' },
  ]}
  caption="An app built by the AI Assistant runs in the same sealed sandbox as any other app."
/>

<Steps>

1. In a chat, describe the app in plain words. Jonas writes: "Bau mir eine App für Besuchsberichte. Ein Dokument ist ein Kundenbesuch: Kunde, Datum, Teilnehmer, besprochene Themen als Liste, nächste Schritte mit Verantwortlichem und Termin. Die Oberfläche soll ein schlichtes Formular sein."

2. The AI Assistant writes the manifest, including a data schema with a description for every field, and the HTML screen. Then it registers the app. If nexxus refuses the package, the AI Assistant gets the reason (for example `manifest.label is required`) and corrects it.

3. The AI Assistant answers with the app's ID. Jonas opens <MenuPath to="Start > Apps" /> and finds <Ui>Besuchsberichte</Ui> under <Ui>My apps</Ui>, marked <Ui>Own app</Ui>.

4. He asks the AI Assistant for a first document ("Leg einen Besuchsbericht für die Nordwind AG von heute an") or clicks <Ui>Create & open</Ui> himself. He tries every field once before he shares the app with colleagues.

</Steps>

:::caution[Check what the AI Assistant built]
The AI Assistant writes real code. nexxus makes sure the package is complete and the schema is valid, and the sandbox keeps the app away from your data. Whether the form does what you meant, only you can tell. Try it with a test document first.
:::

Because Jonas is not an administrator, the app is his. If the whole project team should use it, an administrator such as Jana Brandt has to install it for the tenant. The simplest way is to let the administrator ask the AI Assistant for the app in the first place. Developers who want to maintain an app over time build it as a package, as described in the [developer reference](/apps/build/).

## Set up an installed app

Clicking an app's card under <Ui>My apps</Ui> opens its page. This is where the app is looked after.

<Screenshot src={shot_apps_create_app_page} url="/dms-apps/app/visit-report" alt={"The page of the Besuchsberichte app with its figures and settings"} caption={"The app's page shows what the installed version brings and what the AI Assistant gets."} />

- **Figures.** <Ui>Documents you can see</Ui>, <Ui>Versions</Ui>, <Ui>Renderer size</Ui> and <Ui>Document format</Ui> (<Ui>JSON + schema</Ui> or <Ui>Text</Ui>).
- **<Ui>Settings</Ui>.** What the installed version brings: <Ui>Several documents in tabs</Ui>, <Ui>Assistant per the app</Ui>, the document format and <Ui>Menu entries of the app</Ui>. Below them, the switch <Ui>Assistant for this app</Ui>. Switching it off asks for confirmation (<Ui>Switch off</Ui>), because the AI Assistant then neither reads nor changes any document of this app, for everyone, and ongoing conversations about these documents end.
- **<Ui>AI instructions</Ui>.** The instructions the app brings for the AI Assistant, and your <Ui>Addendum</Ui> of up to 8000 characters. <Ui>Save addendum</Ui> stores it. <Ui>What the assistant sees</Ui> shows the full text the AI Assistant gets. The addendum stays when you publish new versions.
- **<Ui>Documents</Ui>.** The 50 most recently changed documents of this app that you may open, with their folders.
- **<Ui>Version history</Ui>.** Every published version with date, uploader and what it changed.

Only the app's owner and administrators can change the switch and the addendum, upload versions or remove the app. Everyone else sees the page read-only: <Ui>Only the app's owner and administrators can change this.</Ui>

## Publish a new version

Jonas's colleagues ask for a field "Wettbewerber". A developer adds it, raises the version number in the manifest to 2, writes a changelog entry and gives Jonas the new `visit-report.nxa`. Updating keeps every existing report.

<Steps>

1. Open the app's page from <Ui>My apps</Ui>.

2. Click <Ui>Upload new version</Ui> and choose the new `.nxa`.

3. The dialog <Ui>Publish new version</Ui> opens and nexxus checks the package before you confirm. You see <Ui>Installed</Ui> `v1` and <Ui>New version</Ui> `v2`, the file name, and under <Ui>What changes</Ui> the changelog entries of every version between the installed one and the new one.

   <Screenshot src={shot_apps_create_publish_dialog} url="/dms-apps/app/visit-report" alt={"The dialog for publishing version 2 of Besuchsberichte, with its changelog"} caption={"nexxus checks the package before you confirm and lists what changes."} />

4. If the package cannot be released, the dialog shows why in red and the button stays disabled. If the package brings no changelog, the dialog says <Ui>The package has no changelog.</Ui>

5. Click <Ui>Publish version</Ui>. The page shows <Ui>Version v2 was published and is active from now on.</Ui> and the version history gains a row with the changes.

</Steps>

The rules the dialog repeats: the package must carry the same app ID and a higher version number than the installed one. The previous version stays in the history, and documents in Files are not touched. Your addendum and the assistant switch carry over.

## Remove an app

On the app's page, <Ui>Remove app</Ui> (or the bin icon on its card) opens a confirmation. Type the app's ID until the dialog shows <Ui>Match: button unlocked</Ui>, then click <Ui>Remove</Ui>.

The app is hidden, not deleted. Its documents stay in Files but cannot be opened in the app until the same app is imported again. A new import of the same ID brings the app back with its old documents, starting with an empty addendum and the assistant switched on. The built-in Kanban board and Markdown editor cannot be removed.

## The AI Assistant's tools for apps

The AI Assistant uses these tools when you ask it to work with apps. They are part of the connector <Ui>Apps</Ui>.

| Tool | Connector action | What the AI Assistant does with it |
|---|---|---|
| `nx_dmsapp_list` | <Ui>List apps</Ui> | Lists every app with its ID, name, description, data schema, its own instructions and where it is opened. The AI Assistant calls this before creating anything, and when you ask it to open an app. |
| `nx_dmsapp_create` | <Ui>Build and change apps</Ui> | Creates a new document of an app, with content that the server checks against the app's schema, in a folder of your choice or in My files. |
| `nx_dmsapp_update` | <Ui>Build and change apps</Ui> | Changes an existing document, either as a whole or as a list of targeted changes (JSON Patch) for large documents. Needs your edit right on the document. The change appears live for everyone who has it open. |
| `nx_dmsapp_register` | <Ui>Build and change apps</Ui> | Registers a new app from a manifest and an HTML screen that the AI Assistant wrote. |
| `nx_dmsapp_import` | <Ui>Build and change apps</Ui> | Installs a `.nxa` file that is attached to the chat or stored in Files. |
| `nx_ui_open` | (always available) | Opens a page for you: a document (also full screen), an app's page, or another page of nexxus. |

The AI Assistant never gets more rights than you have: `nx_dmsapp_update` checks your edit right on the document, and `nx_dmsapp_create` your right to write into the chosen folder. When the assistant is switched off for an app, every one of these tools refuses that app's documents.

## What happens behind the scenes

- **Documents** are ordinary files in Files with the ending `.<app ID>.nxd`. Folder, sharing, versions and status work like for any file.
- **Apps** are stored per tenant in nexxus itself, never in Files. Every published version keeps a copy of its package and a checksum, which is what the version history shows.
- **Every change from the AI Assistant** is checked against the app's data schema on the server before it is saved, and becomes a version of the document.
- **Live editing** sends each change to everyone who has the document open. If two saves collide, nexxus fetches the other state, merges both and saves again.
- **The sandbox** keeps every app, imported, own or built by the AI Assistant, without network access and without your rights. That is why installing an app is open to everyone.

## When something goes wrong

Errors from the app list and the app's page appear in red at the top. Messages that come from the package check are shown as nexxus produces them, some in English, some in German.

| Message | What it means | What to do |
|---|---|---|
| `manifest.label is required` (and the same message for `contentType`) | The package's manifest misses a required field. | Ask whoever built the app to add it. The fields are listed in the [developer reference](/apps/build/#the-manifest). |
| `manifest.id must be lowercase letters/digits/hyphens (e.g. 'kanban')` | The app ID breaks the naming rule. | Use 2 to 40 characters: lowercase letters, digits and hyphens, starting with a letter. |
| `app.html exceeds 2000000 bytes` | The app's screen is larger than 2 MB. | The app has to get smaller, for example with fewer embedded pictures. |
| `.nxa is missing manifest.json` or `.nxa is missing app.html` | The file is not a complete app package. | Check that both files are inside the ZIP. |
| `Die App '<id>' ist schon installiert. Für eine neue Version bitte „Neue Version hochladen“ auf ihrer Seite verwenden (manifest.version erhöhen).` (already installed, use Upload new version) | You imported an app that is already there. | Open the app's page and use <Ui>Upload new version</Ui>. |
| `Die ID '<id>' ist schon von einer anderen App belegt; bitte im Manifest eine andere ID (manifest.id) wählen.` (ID taken by another app) | Someone else's app uses the same ID. | Change the `id` in the manifest. |
| `'board' ist eine eingebaute App; bitte im Manifest eine andere ID (manifest.id) wählen.` (built-in app ID) | `board` and `markdown` are reserved. | Choose another ID. |
| `Für eine neue Version muss manifest.version höher sein als die installierte (installiert: v1, Paket: v1).` (version must be higher) | The new package has the same or a lower version number. | Raise `version` in the manifest and build the package again. |
| `Das Paket gehört zur App „<id>“ (manifest.id), nicht zu „<id>“.` (package belongs to another app) | You uploaded the package of a different app on this page. | Upload it on the right app's page, or import it as a new app. |
| `Diese App gehört jemand anderem. Eine neue Version hochladen oder die App entfernen dürfen nur ihr Besitzer und Administratoren.` (belongs to someone else) | Only the owner and administrators may update or remove an app. | Ask the owner or an administrator. |
| <Ui>Apps are switched off. An admin can switch the "Apps & workspace" area back on in the setup.</Ui> | An administrator switched the area off. | Ask an administrator to switch on <Ui>Apps & workspace</Ui> under <MenuPath to="Administration > Setup > Areas" />. |
| <Ui>No app registered for "&lt;app&gt;".</Ui> | The document belongs to an app that was removed or never installed in this tenant. | Import the app again. Its documents open again afterwards. |
| `Der Assistent ist für die App '<name>' ausgeschaltet. Ihre Dokumente bearbeitet nur, wer sie selbst öffnet.` (assistant switched off for this app) | The AI Assistant refused because the app's assistant switch is off. | Edit the document yourself, or ask the app's owner to switch the assistant back on. |

## Next steps

<CardGrid>
  <LinkCard title="Program apps" description="For developers who write an app themselves: package and document formats, the protocol, testing." href="/apps/build/" />
  <LinkCard title="Case studies" description="How teams use apps in workshops, sales and quality management." href="/apps/case-studies/" />
  <LinkCard title="What apps are" description="The sandbox, collaboration and settings." href="/apps/overview/" />
</CardGrid>