# Indicator data (/docs/analytical-apps/pipeline/indicator-data)



An **indicator-data** node pulls metrics from one of your indicator apps into this
pipeline. It is the bridge between the two kinds of app: it lets an analytic app
read the numbers you have been collecting in an indicator app and combine them with
other data.

If you track metrics like fuel use or electricity in an indicator app, this node is
how you bring those figures into an analytic app alongside, say, your financial data.

## Choose what to pull in [#choose-what-to-pull-in]

When you add an indicator-data node, you tell it what to fetch:

* the **source indicator app** to read from - the list offers only the indicator apps you
  may import from: those whose data you can read, and an app in a personal space only for an
  app in that same space,
* which **indicators** (metrics) you want,
* the **period range** and **period type**, for example monthly values across a
  span of months or years,
* optional **dimension filters**, to narrow the metrics to particular breakdowns,
  such as one region or site (see [Dimensions](../../indicator-apps/dimensions/other-dimensions.mdx)),
* and whether to **Include dimension labels**.

Leave **Include dimension labels** off and each breakdown arrives as its short
technical id, for example `de_south`. Turn it on and the node adds a second column
next to each one holding the readable member name, for example "South". Turn it on
when the figures end up in a table or a chart people read: the label is what belongs
on the axis or in the column heading, while the id stays the reliable thing to join
and filter on.

## How the values are captured [#how-the-values-are-captured]

The metrics are captured as a **snapshot** when the pipeline runs. In other words,
the node records the indicator values as they stand at the moment of the run, so
the rest of your pipeline works from a stable set of figures. Run the pipeline
again whenever you want to refresh that snapshot with the latest values.

From there, the indicator values flow into the nodes connected after this one,
letting you blend collected metrics 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 indicator-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 indicator app - and only ever that app's **published** structure with its
collected values, never its drafts. Keep that in mind before importing from an app
whose readers are a smaller group than this app's.
