# Analytic app data (/docs/analytical-apps/pipeline/analytic-data)



An **analytic-app-data** node imports the result of a node from **another** of your
analytic apps into this pipeline. It lets several apps build on one shared,
already-published result instead of copying the same data or rebuilding the same
steps in every app.

A common pattern is a shared "reference data" app whose output several reporting
apps re-use, or a heavy data-preparation app whose result feeds a handful of
smaller apps. Instead of duplicating that work, each downstream app imports the
result with an analytic-app-data node.

## Choose what to import [#choose-what-to-import]

When you add an analytic-app-data node, you tell it what to bring in:

* the **source analytic app** to read from (one of your workspace's other analytic
  apps),
* the **node** inside that app whose result you want,
* optionally, **which columns** to import and in what order. Leave this empty to
  import every column exactly as it is.

The source-app list offers only the apps you may import from - apps whose data you can
read, and an app in a personal space only for an app in that same space - and marks any
app that has no published result yet, so you can only pick an app that is ready to import
from.

## How the data is captured [#how-the-data-is-captured]

The data is imported as a **snapshot** of the source app's last successful
**published** run, taken at the moment this pipeline runs. Two things follow from
that:

* Only a **published** result is imported. A private preview run in the source app
  is never imported, so downstream apps only ever build on results their owners
  have deliberately published.
* The import is a point-in-time copy. When the source app publishes newer results,
  this app does not change on its own. **Run this pipeline again** to refresh the
  import with the newer values.

The imported node is **read-only**: it shows the imported result as a table, and
you edit the data in the source app, not here. From this node the imported columns
flow into the nodes connected after it, so you can blend the shared result with the
rest of your data.

## Who can change an app that imports another app [#who-can-change-an-app-that-imports-another-app]

An analytic-app-data node carries another app's data into this one, so it is checked
whenever this app's configuration changes:

* You can add an import node, or point one at a different app, only for an app whose
  data you can read. An app in somebody's personal space can be imported only into an
  app in that same personal space, and the Audit Analytics app can never be imported.
* Adding an import can therefore lock colleagues out. Before you save an import node that
  points at a new app, the node says how many people would no longer be able to modify this
  app, for example "3 people will no longer be able to modify this app". It never names them.
* Once this app imports from another app, changing anything in it - its pipeline,
  knowledge base, skills, Visualisation and settings, and publishing it - is open only
  to people who can read every app it imports from. Anybody else is told which import
  node stops them, and can ask for access to the app it imports from.
* They can still repair the app themselves, one import node at a time: deleting such a
  node, or pointing it at an app they can read, is always allowed. Nothing else is - not
  even choosing different columns of the same app. The same holds when the app an import
  node reads from has been deleted. A notice at the top of the editor names the import
  nodes that stop them, so they know which ones to change.
* Restoring an earlier version, or discarding a draft, is allowed only when the version it
  makes current imports from no app they cannot read; a version that does import from one
  stays out of reach, even if it imports from fewer of them.
* Running the pipeline, entering data, exporting and archiving are not affected.

Everybody who can read this app's data also sees what it imports, even without access
to the source app - and only ever the source app's **published** result, never its
drafts. Keep that in mind before importing from an app whose readers are a smaller
group than this app's.