App Playground

Last updated: October 30, 2026

Overview

App Playground is a builder for small applications that run on live D3 Morpheus data, so a team can have the view or tool it needs without waiting for one to ship. Describe the app in plain language, and Morpheus (the D3 AI assistant) writes the pages and the code, proposes the platform data the app needs, and keeps the app working as that data changes. A finished app is published to a permanent link, shared with the people, groups, or roles who should have it, and can also run inside the incident workspace as a widget.

Use it for the views and light tools a SOC builds around its own way of working: a queue the shift works from, with pass-down notes for the next shift; SLA clocks counting down across the queue; where the week's alerts went and how many closed without an analyst; what an incident touches, right on the incident. Apps read incidents, events, artifacts, SLAs, Attack Path Discovery (APD) results, saved reporting queries, integrations, vulnerabilities, and more, and they keep their own settings and the notes their users add.

The builder

builder-overview.png

App Playground is found under Configuration > App Playground. Every app is private to its author until it is explicitly shared.

In short

#

Stage

Where it happens

1

Name the app and pick a starting point

Configuration > App Playground > New app

2

Describe what it should do, by typing

The Build chat, in the builder

3

Connect platform data

The Endpoints rail > Add

4

Check it on test data, fine-tune the code and data

The Preview, Code, and Data tabs

5

Publish it

Publish, in the builder's top bar

6

Give people access, or put it on incidents

Share; the Playground App widget in the incident workspace builder

7

See who uses it, keep a record of what it showed

The Usage tab; Export this page

8

Keep it current as the data changes

The Adaptivity tab

READER NOTE

Screenshots in this article were captured on an internal development site seeded with D3's demo data.

Roles and Access

An app has its own collaborators, separate from platform permissions, so the person who builds a tool decides who gets it. Within one app, each collaborator holds one of three roles.

Role

What it permits

Viewer

Opens the published app. No builder access and no edits to the app.

Editor

Opens the app in App Playground, edits the draft, publishes it, and manages its data on the Data tab.

Owner

Everything an Editor can do, plus sharing and deletion. Whoever creates or imports an app is its Owner.

Sharing adds Viewers and Editors. It can target a person, a group, a role, or all users.

Who may use App Playground at all is set on the role, under Global Settings > Organization Management > Roles.

Playground permissions on a role

A role's Playground permissions, Create App and Edit App, and the separate Run Apps permission

Permission

What it permits

Playground

Views the published apps shared with the role. Without Create App or Edit App, view only.

Create App

Creates apps, with New app or Import.

Edit App

Edits and publishes apps.

Run Apps

Runs published apps inside incident widgets, without App Playground access. Meant for analysts who use apps on incidents but do not build them.

READER NOTE

A role whose access type is App Only gets published apps and nothing else in D3—no builder and no other modules. It is meant for stakeholders outside the SOC whose whole D3 experience is one or two apps.

The App List

The app list is the landing page of Configuration > App Playground, and it is where every app someone has shared with you appears alongside your own. Each card shows the app's thumbnail, name, description, publication status, page count, last-edited time, and the people on it.

The app list

The app list with the search box, the status filter, the sort control and four apps, one of them live with a newer draft
  • Search apps matches on name and description.

  • The status filter narrows the list to All statuses, Published, or Draft. The sort control offers Recently updated (the default), Oldest first, Name A–Z, Name Z–A, and Published first.

  • Status is shown on each card. Draft v1 means nothing is published yet. Live v2 means version 2 is what viewers see. Live v2 · v3 in draft means viewers have version 2 while version 3 is being worked on—so an app can be live and under edit at the same time, and the card says both.

New app and Import both create an app and both need the Create App permission.

Creating an App

Creating an app takes a name and a starting point; everything else can be described in the chat afterwards.

  1. Select New app.

  2. Enter a Name and, optionally, a Description of what the app should do.

  3. Choose a starting point under Start from, then select Create.

The New app dialog

The New app dialog with a name and description entered and the SLA desk starting point selected

RESULT

The app is created from the starting point and the builder opens on its first draft.

Each starting point names its pages and the data it uses, so the choice can be made on what the app will show rather than on its name. A starting point that reads live data arrives with its endpoints already connected, which is why it shows the site's real rows the first time it opens.

Starting point

What it contains

Blank app

One page and the component kit. Describe what you want in the build chat.

Reporting pack

Six pages for people outside the SOC: executive summary, SLA met versus breached, incidents by site and owner, service value, and an evidence pack. Saves its own settings.

Shift handover board

Five pages for the queue a shift works from: mine, unassigned, and stale incidents with hand over, note, and close in place; pass-down notes for the next shift; workload by owner; an activity log; and shared settings.

SLA desk

Three pages: every running SLA clock counting down, how the period went by hour, rule, or owner, and the rules in plain words. Anyone using the app can record why a run missed its goal.

Connection health map

Every integration connection as a tile, green when its last check passed and red when it failed. An analyst acknowledges a failure so others can see who is on it.

Live triage overview

Where the alerts went: a flow from each source to its outcome, who handled each alert—AI, a playbook or rule, or an analyst—and how many closed without an analyst. Narrow it by source or risk level.

Vulnerabilities

Open vulnerabilities by severity, asset, and age, and which are past the number of days your team allows to fix them. Saves your fix targets.

Incident blast radius

An incident widget: what an incident touches, the incidents that share it, and its SLA countdown, with note, hand over, and close one click away.

The SLA desk starting point on live data

An app made from the SLA desk starting point, showing the site's running SLA clocks the first time it opens

READER NOTE

The Live triage overview shows an Analyst hours saved figure that is your own estimate. Set how many minutes an analyst spends triaging one alert by hand, and the page labels the figure as your assumption. Until it is set, a default is used.

The Builder

The builder is a three-column workspace: the Build chat on the left, the app itself in the center, and the Endpoints rail on the right. The center column carries six tabs—Preview, Code, Versions, Data, Adaptivity, and Usage—and the top bar holds the app's status, Share, and Publish.

Building with Morpheus

The Build chat is where the app is made, and it is the surface most of the work happens on. Write a request in plain language—"add an Incidents page with a table of open incidents", "use two columns, and put the summary on the right", "move the navigation to the top"—and Morpheus edits the draft directly. The preview rebuilds within moments. A new app's chat offers Add a page and Change the layout as first requests.

A build request and its reply

A build request in the chat, the folded summary of the steps Morpheus worked through, and its reply describing the pages it added
  • A chip above the message box names what you are looking at—Viewing and the page in the preview, or Editing and the file open in the Code tab—so a request such as "add a column here" refers to it. Select × on the chip to leave it out of the next message.

  • While a request runs, the chat shows the steps as they happen and folds them into a single Worked · N steps summary when the turn ends. Opening it shows what was worked through.

  • While Morpheus edits a file, that file is read-only in the Code tab until the edit completes.

  • Images and pasted text can be attached to a message. A long paste is carried as an attachment rather than as message text, and can be reopened from the history.

  • If a preview build ever fails, the error panel offers a link that hands the exact error back to Morpheus to fix.

READER NOTE

Build chat sessions are per person. An Editor opening the app sees their own chat history, not the Owner's.

Previewing the App

The Preview tab renders the draft exactly as a viewer will see it, inside the app's own frame with its header, navigation, and site scope—so what is on screen is the app, not an approximation of it.

The app's header carries the controls viewers get too: the site picker, which decides which sites' data the app reads; Export this page (see Capturing a Page); the palette; and the light/dark switch. The toolbar above the preview carries the author's controls.

Toolbar control

What it does

Navigation style

Opens the navigation placement picker (see Configuring Navigation).

Preview as an incident widget

Previews the app as a widget on an incident you pick (see Apps in the Incident Workspace).

Preview uses test data

Switches the preview between the app's test data and its live data (see Managing App Data).

Refresh preview

Rebuilds the preview.

Open in new window

Opens the preview on its own.

The palette menu

The five palettes available from the app header

Palette

Accent

D3 Default

Indigo—the platform's own palette, matched to its look in light and dark mode. The default.

Teal

Deep teal.

Classic

The legacy D3 brand blue.

Bronze

Muted bronze.

Gold

Bright gold with a dark label.

Because every color in an app comes from the palette, switching palettes re-skins the whole app—including apps built before a palette existed—without a rebuild. Light/dark and palette are viewer choices; they follow the person, not the app. Apps also use the same dropdowns, checkboxes, and dialogs as the platform, so they look and behave like the rest of D3 in either mode.

READER NOTE

The preview opens on All internal sites; the published app opens on All client sites. If your data lives in internal sites, a page that is full in the preview can open empty for viewers until they pick the scope in the app header.

Connecting Real Data

An app reads and acts on platform data through endpoints—named, pre-authorized routes such as incident.list.query or sla.live.query. Connecting one is how an app stops being a mock-up and starts showing the site's real rows. The Endpoints rail lists what the app uses; Add opens the catalog.

The Endpoints rail

Endpoints the app is connected to, each with its kind and effect badges and a description of what it returns

The endpoint catalog

The Add endpoints dialog, grouped into Data, Actions and Commands, each entry saying what it is for and what it returns

The catalog groups what is available into Data, Actions, and Commands, with In this app listing what the app already uses. Each entry says what it is for and what it returns, so the right one can be picked without reading any code. Two badges qualify every entry: the first names its kind (query, command), the second what it does (read, mutating, action).

What an app can read:

Data

What the app gets

Incidents

Lists, counts, and one incident in detail: summary, notes, evidence, playbooks, tasks, findings, recommendations, remediations, attachments, linked incidents, SLA, stages, MITRE techniques, custom fields, and the AI summary.

Events

Lists, counts, and one event in detail, including how it was handled.

Artifacts

Lists, counts, and one artifact in detail with its threat intel: the verdict, every vendor's verdict, the network owner, and the location.

APD results

Each event's verdict (Open, Dismiss, or Escalate) with its confidence and the rule that decided it, the reasoning behind it, the events it correlated, how far an investigation has got, and the investigation of an incident APD escalated.

SLAs

Running clocks with the same time left as each incident's SLA card, results for a period, counts by rule, site, owner, day, week, or hour of day, one incident's SLA timeline, and the rules in plain words.

Saved reporting queries

The queries you can reach on Reporting > Queries, run by the app and charted.

Integrations and connections

The integration catalog, each integration's commands, and every connection with its health and logo.

Data ingestion

The data sources, their runs, and one run in detail.

Vulnerabilities

Open vulnerabilities and counts by severity, asset, and age.

Pending tasks, playbooks, global lists, command runs

Pending tasks across the site scope, the playbooks you can open and a playbook's latest run data, global lists and their rows, and the ad-hoc run log the Command Logs page shows.

The app's own data

Its settings files and the records its users add (see Managing App Data).

Lists can be filtered by any filter the dashboard grid offers you—including custom fields and SLA rule columns—and counts can be grouped by them, so an app can show "every open incident I own" or "incidents untouched for five days" with the same totals as the incident list.

Actions an app can open

add-endpoints-actions.png

Action endpoints open the platform's own windows rather than acting behind your back: add a note to an incident, set its owner, close it, bulk edit fields on up to 50 incidents, create an incident, upload a file, open a record, schedule a command, set up a scheduled fetch, or add or edit a connection. Each window checks your rights exactly as it does elsewhere in D3, and when it closes it tells the app what happened—saved, cancelled, or refused—so a handover app can, for example, log a handover once the note is actually saved. Commands holds a single entry that opens the platform's Execute Command dialog on an integration command. Each command run started from an app is recorded in the audit log with the app, its version, who ran it, and the outcome, so an app's owners and auditors can see what it did.

  • Every endpoint call is authorized as the person using the app: site scope, roles, and record access all apply. Identity is set by the platform and is never passed in by the app, so an app cannot show one person another person's data.

  • An app saves data only in response to something the person using it clicked. It cannot write on its own while a page is merely open.

  • Morpheus can propose endpoints during a build ("connect real data"). A proposal connects nothing by itself—it appears as a confirmation card in the chat, and only approving it connects the endpoints. If the catalog has nothing for what is needed, Propose it in Build starts that conversation.

  • Apps that list integrations or connections show each integration's logo, the same one the rest of the platform uses.

Configuring Navigation

Every app carries a configurable navigation system, so the way pages are reached is a setting rather than something to build. Where the navigation lives is one choice—docked or floating, on any of the four edges—made in the Navigation style picker or by asking Morpheus.

The navigation placement picker

The Floating switch and the four edges around a screen outline, with the current placement written underneath

Placement

Rendering

Docked left / right

A collapsible side menu. Section headings group the pages; sub-pages render as expandable groups; a long page list scrolls inside the menu.

Docked top / bottom

A full-width bar. Pages that do not fit collapse into a More menu; the current page always stays visible.

Floating (any edge)

A floating dock of icons over the content, with flyouts for sub-pages and an overflow menu when the list outgrows the screen.

A docked top bar

The app's pages as a bar across the top of the app frame

A floating dock

A floating dock of page icons resting over the content near the bottom edge
  • Section headings group the pages of a docked side menu under small all-caps headings, so an app with many pages reads as a few areas rather than one long list. Ask Morpheus to group the pages, or edit the app's page list on the Code tab. Bars and floating docks show the same pages without the headings.

  • Sub-pages: a page may declare one level of children—"Settings" containing "General" and "Advanced". Side menus render them as groups; bars and docks render flyouts.

  • Icons come from a fixed set; a page can name its icon, and otherwise one is picked from the page's name.

Section headings in the side menu

A side menu grouped under the headings TODAY and TEAM

The placement applies to the app for everyone who opens it—it changes the layout the pages are designed around, so it is an author setting, not a viewer one. On a published app with no draft, the picker is read-only until New draft opens one.

Working with the Code

The Code tab exposes every file in the draft, for the times when describing a change is slower than making it. The tree shows the app's own files first; the platform's locked foundation files sit under a collapsed PLATFORM section with a padlock and a count. Locked files are maintained by the platform— selecting one shows it read-only—and an editable file is marked Editable above the editor.

The Code tab

The file tree with the app's own files above a collapsed PLATFORM section, and a page's file open in the editor
  • The two icons above the tree create a file or a folder. New file opens a dialog with a Folder picker and a File name field. No extension is needed; .tsx is assumed.

Creating a file

The New file dialog with its folder picker and name field
  • Files and folders the app owns can be renamed, moved, and deleted from each row's menu. Locked files, and any folder holding one, cannot.

  • Packages lists the libraries an app's code may use.

  • When the platform ships newer versions of its foundation files, a banner above the tree says how many, and the Code tab carries a count badge. The update control applies the newer files—and adds any the app does not have yet—without touching the app's own code.

The platform update banner

A banner saying nine platform files have newer versions, with its update control, and the Code tab carrying a count badge

Managing App Data

App data is what an app keeps for itself: files for its settings—a shift roster, a stale-after threshold, a fix target—and records for what its users add, such as handover notes, RFI replies, and acknowledgements. It is how an app remembers things between visits without anyone needing rights to edit global lists.

Files

Records

What they hold

Settings shared by everyone who uses the app

Entries the app's users add, in named collections

Who adds or saves

Owners and Editors

Anyone who can open the app

Who changes or deletes

Owners and Editors

The record's author, or an Owner or Editor

Who reads

Anyone who can open the app

Anyone who can open the app; a private record only its author

How much

Up to 20 files of 256 KB each

Up to 100,000 records in up to 50 collections

A Viewer who tries to save a settings file gets a refusal in a sentence and nothing changes. Each file carries a revision, so a save made from an older copy is refused rather than overwriting someone's newer change. Saves to settings files, and changes to another person's record, are recorded in the audit log. Deleting an app deletes its data.

Records an app's users add

The Pass-down notes page with three notes, one of them private and marked with a lock

Test Data and Live Data

Every app has two copies of its data: live, which the published app and incident widgets always use, and test, which the builder preview uses. Testing a save in the preview therefore never changes what viewers see. Preview uses test data in the preview toolbar switches the preview to live data when you need to check against it; the preview goes back to test data each time the app is opened.

The Data Tab

The Data tab shows an app's files and records in either copy, for its Owners and Editors. Choose Live or Test at the top.

The Data tab

data-tab.png
  • Files lists each settings file with its size, revision, and who saved it last. Edit a file as JSON with its pencil, delete it, or add one with New file—typed, or started from a .json file you drop in or choose.

  • Records lists each collection and its records, newest first, with who added them. Delete one record, or empty the whole collection. Another user's private record shows as its details only, never its content.

  • Copy live to test replaces the test copy with the live data, so the preview can be tried against real settings and records. It asks for confirmation first, naming how many files and records each side holds.

WARNING

Copy live to test replaces everything in the test copy. Anything saved only in the test copy is lost.

Versions and Publishing

Every app has exactly one draft, and publishing is what turns that draft into the thing other people see. The Versions tab lists the history: each version shows what changed—files added, modified, and removed—with the author and the time, and selecting a version shows its changes from the one before it, file by file.

The Versions tab

Version history with the change between two versions, and the Export and Restore controls

Selecting Publish freezes the draft as the new published version. The published app is served from a permanent link that never changes between versions, so viewers always see the current published version without updating any bookmark. An app whose code uses something that does not exist cannot be published, and the message names the file.

A published app's top bar

published-state.png
  • After publishing, the app is locked until New draft opens a fresh draft to continue editing.

  • Copy app link (the link icon) copies the app's permanent link.

  • Restore on an older version copies it into a new draft. Nothing is ever destroyed by restoring.

  • Unpublish takes the app off its link and returns it to draft. Viewers lose access to it; the version history is kept.

READER NOTE

Publishing also builds the app on the server, so viewers receive a ready-built app rather than building it in their browser. This is why a large app opens quickly for someone who has never seen it before.

Tracking Usage

The Usage tab answers whether an app is actually being used, and by how much, over the last 30 days. It counts published traffic only—what real viewers loaded and called. The builder's own preview is never counted.

The Usage tab

usage-tab.png
  • App views counts how many times the published app was opened.

  • Endpoint calls counts the platform data calls those views made.

  • Call success rate shows what proportion of those calls succeeded, so a failing endpoint shows up here before anyone reports it.

  • The chart breaks the same period down by day, switchable between Calls and Views, and the table under it splits the calls per endpoint with a failure count for each—so a single misbehaving endpoint stands out rather than being buried in the total.

Days are counted in your own local day, so an evening's use is reported on the evening it happened. Before an app is published the tab says Usage starts at publish; once published but not yet opened, it says No usage recorded yet.

Sharing an App

Sharing is how an app reaches the people it was built for; until it happens, an app is visible to its author and nobody else.

  1. Select Share.

  2. On the Share tab, search for a person, a group, or a role—or choose All Users under Share to All.

  3. Choose Viewer or Editor under Invite as, then select Share.

The Share dialog

share-dialog.png

RESULT

The person, group, or role appears under People with access with the role chosen. An Owner can change it there or remove it.

Invited as

What they get

Viewer

Opens the published app from My Apps in the Workspace navigation. Never sees the builder.

Editor

Opens the app in App Playground and can edit and publish it. Their chat sessions are their own.

The Published App

A published app runs full screen at its permanent link, with its own navigation, header, site picker, and theme controls, and nothing else from the platform around it. It reads live data as the signed-in viewer, under that viewer's own permissions—so two people opening the same app can legitimately see different rows. People it is shared with find it under My Apps in the Workspace navigation.

A published app

The published Tier 1 Shift Handover app running full screen on live data

READER NOTE

A person whose role has Run Apps but not Playground uses apps only inside incident widgets. Opening an app's full-page link tells them their role runs apps inside incident widgets only.

Apps in the Incident Workspace

A published app can run as a widget on the incident workspace, so a custom view sits next to the rest of the investigation instead of in a separate app. On each incident, the app is given that incident and reads it at the incident's own site—an app such as Incident blast radius shows what that incident touches, its SLA clocks, and its note, hand-over, and close actions.

An app on an incident

The Incident Blast Radius app as a widget on an incident, showing that incident's SLA clocks and its note, hand-over and close actions

To put an app on incidents:

  1. Publish the app, and share it with the people who will use it.

  2. Open Configuration > Incident Type Manager, choose the incident type, and open the Incident Workspace layout to change.

  3. Add the Playground App widget, select Choose app, and pick the published app.

  4. Save the layout.

An app in the workspace builder

The workspace builder with an app widget showing its sample preview, and the widget list on the right

RESULT

Every incident that uses the layout shows the app, titled with the app's name. In the builder, the tile shows a sample preview, as every widget does, rather than running the app.

  • Only published apps can be chosen. A later rename of the app does not retitle widgets already placed.

  • People who cannot open the app see a placeholder in its place, not an error.

  • Run Apps lets analysts use apps on incidents without any access to App Playground itself.

  • The widget never hides itself as empty, even when the layout's hide-when-empty setting is on.

Preview as an incident widget in the builder's preview toolbar shows a draft as it will appear on an incident you pick, so a widget app can be built and checked against real incidents before it is placed.

Previewing an app as an incident widget

The builder previewing an app as a widget on a chosen incident, the incident's number shown in the preview toolbar

Capturing a Page

A snapshot is a file of exactly what an app page showed at one moment—the triage view when an incident was escalated, the summary that went out on a given day—kept as evidence for audits, handovers, and decisions. Anyone who can open a page can export it; there is no separate permission.

Export this page in the app header opens the export. In the builder it opens the Export tab of the Share dialog; in the published app it opens the same choices on their own. Incident widgets do not offer it.

The Export tab

snapshot-export.png

Format

What you get

HTML

A standalone web page. It opens offline, exactly as captured, and runs no scripts.

PDF

Rendered on the server, with selectable text.

PNG

An image of the whole page.

Every file is stamped with who exported it, when, the site, the app and its version, and a snapshot ID. In a PDF or PNG the stamp sits outside the page; in an HTML file it is part of the page. A snapshot contains only what the exporting person's page showed, which is already limited to what they can see.

A PNG snapshot

An exported PNG snapshot of the Pass-down notes page, stamped with the app version, the page, who captured it, when, the site and the snapshot ID

Each export is recorded with the file's SHA-256 fingerprint, and that record is what proves a file—the file itself is not stored anywhere in D3. Exports are also listed in Global Settings > Audit Log under the Playground type.

Verifying a File

Verify a file answers whether a file is byte for byte one exported from this app. It is on the builder's Export tab, for the app's Owners and Editors.

  1. Drop the file on Verify a file, or select Choose a file.

A verified snapshot

A dropped file recognised as identical to an export, with who exported it, when, the app version, the page, the site and the format

RESULT

Identical to an export names who exported it, when, the app version, the page, the site, and the format. No matching export means the file was edited after it was exported, or came from somewhere else.

The file is checked in your browser; only its fingerprint is sent. Export history lists every export of the app, newest first, with its fingerprint.

Export history

Every export of the app, newest first, with who exported it, the version, page, site, format and fingerprint

Moving an App Between Sites

An app built on one site can be carried to another—a second environment, a different customer site, or a colleague's tenant—by exporting it and importing the file there. Nothing has to be rebuilt.

  1. On the Versions tab, select the version to carry and select Export.

  2. On the destination site, open Configuration > App Playground and select Import.

  3. Choose the exported file.

An imported app

The notification after an import, saying the app was imported and its 15 endpoints connected, above the new app's Draft v1 status

RESULT

The app is created on the destination site as a new draft and opens in the builder. Its endpoints and command selections are reconnected automatically, and a notification states how many were connected.

  • The export file carries that version's code together with the app's pages, endpoints, and command selections. Imports are recorded in the audit log, naming the app and version they came from.

  • Import always creates a new app, owned by whoever imported it. It never merges into an existing app, so importing twice gives two apps rather than overwriting the first.

  • Anything the destination site does not have—an endpoint that site lacks, a command that is not configured there—is named in the notification, and every connection stays visible on the Endpoints rail so it can be reviewed or replaced.

Adaptivity

Adaptivity is a scheduled reviewer that keeps an app working after it is built: Morpheus regularly compares the app with what it is for and with the data it actually reads, and raises what it finds. It exists because the platform keeps changing underneath a published app—a field is renamed, a new status appears, an endpoint starts returning something else—and without it those changes surface as a viewer's broken page.

Nothing is ever applied on its own. Every level ends with a proposal a person approves.

Reviews are off until they are switched on for an app. Reviews on starts the schedule—Morpheus then reviews the app every hour—and the banner states when the last review ran and when the next one is due. Review now runs one immediately, and Reload findings fetches the latest.

The Adaptivity tab

adaptivity-tab.png

Reviews switched on

The review banner with reviews on, saying when the last review ran and when the next is due

ALERT

Anything that writes data—isolating a host, reassigning a shift—always waits for approval, whatever suggestion level is chosen. No level can override that.

Findings and Fixes

A finding is something the review noticed: a field the app stopped showing, data it never displays, or a page that crashed for a viewer. Findings wait under Waiting on you until they are answered, and move to Settled once they are. The count on the Adaptivity tab is how many are still waiting. The review can also raise a finding as a message in the build chat, marked ADAPTIVITY, and wait for your answer there.

A suggestion in the build chat

A message from the review in the build chat, offering to show data the app ignores and waiting for an answer

Where the level allows it, a finding arrives with a fix already written and built, so what is previewed is exactly what lands and anything that failed to build is never offered.

Control

What it does

Accept as a draft

Applies the change to the draft. Nothing reaches viewers until the app is published.

Approve & publish

For an app with no draft: applies the change and publishes it in one step. The tab says which of the two will happen before the choice is made.

View change

Opens the exact file changes the fix would make.

Discard

Throws the fix away and leaves the finding open.

Dismiss

Answers the finding without a change.

WARNING

On a published app with no draft, approving a fix publishes it immediately—viewers see the change at once. Check which of the two the tab says will happen before approving.

What the App Is For

What this app is for records the app's purpose, and it is the yardstick every review measures against—a review with nothing to compare to has nothing useful to say. It starts from the description given when the app was created, can be edited by hand, or Improve with Morpheus writes one from the app's build history and shape.

How Much Morpheus Suggests

The suggestion level controls how much work Morpheus does before asking, not whether it asks.

Level

What it does

Just tell me

Points out what drifted—a field the app stopped showing, data it never displays—and leaves the fix to you. No changes are drafted.

Keep up with the data (recommended)

Also drafts the small ones when you ask: a new field becomes a column, a renamed label follows, a new filter value appears. Nothing moves or disappears, and nothing is drafted until you ask.

Reshape the app too

Also drafts changes to the layout—adding, moving, and retiring panels and pages—within the rules you set.

At Reshape the app too, a set of rules describes what matters about the app in terms of outcomes—"when data appears that this app does not show, make it visible"—and each rule says what Morpheus may do about it.

Rule mode

What Morpheus does

Watch

Notices it. Says nothing, changes nothing.

Ask me

Raises it and waits for you.

Handle it

Writes a fix for you to approve. Nothing goes live on its own.

An app starts with a set of rules already saved. Rules apply only at Reshape the app too; at the lower levels the tab says how many are saved and that they sit idle rather than being deleted, so nothing is silently switched off by changing the level. Changing a rule takes effect on the next review and never republishes the app.

What the App Needs from Its Data

What this app needs from its data is the record of what the app was reading when it was last published, written from the code itself. It is what each review compares live data against, which is how a renamed field or a vanished value is noticed at all.

An app gets this record the first time it is published, so an app that has never been published has nothing for a review to compare against.

  • Incident Workspace

  • SLA

  • Reporting Queries

  • Connections

  • Role and Permission Management

  • Audit Log