Skip to main content

Mapping Manager

Feature Guide — Mapping Your Source Data onto a Target Model​

|  Last updated: September 2026

Contents​

  1. Overview
  2. Key Concepts
  3. Finding Your Way Around
  4. Creating a Mapping and Its Versions
  5. Mapping Fields in the Grid
  6. Auto-Map and AI Suggestions
  7. Transform Mappings and the Formula Builder
  8. Value Mapping
  9. Reference Data Mapping
  10. Configuring the Template and the Grid Columns
  11. Search, Notes, History and Data Relevancy
  12. Importing and Exporting a Mapping
  13. The Mapping Detail Tabs
  14. Mapping Manager vs. the AI Mapping Workbench
  15. Quick Reference

1. Overview​

The Mapping Manager is where you decide, field by field, how your incoming source data lines up with the target model in OnCoor. For a given business object — say Material Data or Customer Data — it answers one question for every target field: where does this value come from, and what has to happen to it on the way in?

The answer might be simple ("copy the source column straight across"), or it might involve a transformation (trim it, reformat a date, combine two columns), a lookup against reference data, or a value translation (the source says 1, the target expects Active). The Mapping Manager holds all of these in one grid, keeps a full history of who changed what, and moves each mapping through a review-and-approval cycle before it goes live.

What you can do here

  • Map each target field to a source column, a formula, or a reference lookup.
  • Let OnCoor propose the mappings for you with Auto-Map, optionally sharpened by AI suggestions.
  • Build transformation logic without writing raw code, using the Formula Builder.
  • Version and effective-date your mappings, and send them through approval.
  • Import and export a whole mapping as an Excel workbook.
  • Track every change with notes and a full audit history.

WHERE TO FIND IT — There are two ways in:

  • From the menu — open the Management menu and choose Mapping Manager. The left panel is headed MAPPINGS.
  • From the Conversion view — this is the home screen made of cards, each with pills (action chips) inside it. Find the Migration card and click its Mapping pill. That opens the Mapping Manager straight onto your object, with the Conversion layer already selected — so you can start mapping without picking the layer first.

Both routes land you in the same tool. What you can see and change depends on your permissions — some people have view-only access, and approving a mapping is a separate permission again.

2. Key Concepts​

A few ideas make everything else easier to follow.

Domain layer. Your data moves through OnCoor in stages — for example a Conversion layer and a Cleansing layer. Each stage is a domain layer, and a mapping always belongs to one layer. You pick the layer first, then the object you want to map. Only layers that are switched on (and set up to receive extracted data) appear in the list.

Source and target. The target is the OnCoor model you're filling — its tables and fields are fixed by the object you chose. The source is where the data comes from — a system, a file, or a queue you attach to the mapping. Mapping is the act of connecting the two.

A mapping and its versions. Each object in a layer has one mapping, but that mapping can have several versions, each with an effective date (when it starts being used) and an expiry date. This lets you prepare next quarter's mapping while today's is still running. OnCoor shows the most recent version whose effective date has already arrived.

Status. Every mapping version moves through a simple cycle:

StatusWhat it means
OpenThe version is being worked on and can be edited.
PendingIt has been submitted and is waiting for an approver. Editing is locked.
ApprovedAn approver has signed it off. Editing is locked.
DeniedAn approver sent it back. It can be reopened for changes.

Field status. Inside the grid, each target field is also marked as Active (mapped and in use), Draft (mapped but not yet finalised), or Unmapped (still needs attention). The counts at the top of the grid summarise these.

3. Finding Your Way Around​

Open Management → Mapping Manager. The screen has two parts: a navigation panel on the left and the mapping grid on the right.

The left panel (MAPPINGS). At the top is a layer dropdown — choose the domain layer you're working in. Below it, the Add Mapping button starts a new mapping, and a search box filters the list. The rest of the panel is a tree of your business objects, grouped by area; click an object to load its mapping into the grid. You can collapse the panel with the arrow at the top to give the grid more room.

The grid (right). This is the working area. Across the top sits a summary strip showing three numbers for the object you're on:

NumberWhat it counts
Total FieldsEvery target field in scope for this mapping.
ActiveFields that are fully mapped and in use.
DraftFields mapped but still marked as draft.

Each row of the grid is one target field, with its source, its type, its status, and the actions you can take. A toolbar sits above the grid. Most actions are small icon buttons — hover over any icon to see its name. Here's what each one does:

Toolbar iconWhat it doesCovered in
Version / effective-date selectorSwitch between the mapping's versions.Section 4
NotesOpen the notes panel for this mapping.Section 11
ConfigurationOpen the Configure Template / Reconfigure Columns pages.Section 10
ImportLoad a mapping from an Excel file.Section 12
ExportDownload the mapping as Excel.Section 12
More (…)A menu holding Audit History and Re-map / Auto-map.Sections 6 & 11
Submit for Approval / Approve / Deny / Re OpenThe approval actions, on the right. Which ones show depends on the current status.Section 4

Each row also has its own icons on the right-hand side: Delete, Edit, Add (add another source row for the same field), and History (the change history for just that field).

NOTHING SHOWS UNTIL YOU PICK AN OBJECT — The grid stays empty until you select a layer and an object from the tree. If you've followed a link from a home-page card, OnCoor pre-selects the layer for you.

4. Creating a Mapping and Its Versions​

4.1 Creating a mapping​

Steps

  1. In the left panel, choose the domain layer you want to map in.
  2. Click Add Mapping.
  3. Pick the business object to map. The list shows only objects that don't already have a mapping in this layer.
  4. Give the mapping a name, and choose its source (and a queue, if your setup uses one).
  5. Optionally switch on Auto-Map to have OnCoor propose the field mappings straight away (see Auto-Map and AI Suggestions).
  6. Save. The new mapping opens in the grid, ready for you to fill in or refine.

4.2 Adding a version​

When you need to change a mapping that's already approved and running — without disturbing what's live — you create a new version rather than editing the current one.

Steps

  1. With the mapping open, use the version control in the toolbar and choose to add a version.
  2. Set the effective date (when this version should take over) and, if needed, an expiry date.
  3. Submit. The new version is created as Open so you can edit it. OnCoor keeps showing the currently-effective version everywhere else until the new one's date arrives.

ONE MAPPING, MANY VERSIONS — Think of the mapping as the object's permanent record and versions as its dated revisions. Because versions are effective-dated, you can build and approve a change ahead of time and let it switch itself on automatically.

4.3 Adding more target tables (Expand Objects)​

Some objects span more than one table. If the mapping needs to cover an additional target table, use Add Table (also available from the add button on the grid) to bring that table into the mapping's scope. Its fields then appear as new rows to map.

5. Mapping Fields in the Grid​

The grid is where the actual mapping happens. Each row is a target field, and mapping it means telling OnCoor two things: what kind of source feeds the field (its map type), and then the specific source for that type. The row's key columns work together:

  • Type — the map type you choose (Column, Static Value, Reference Value, and so on). This is the first decision, because it changes what the next columns ask for.
  • Source — what feeds the field. Its behaviour changes with the type: it might be a source-table dropdown, a reference dropdown, a formula editor, or a free-text box for a constant.
  • Source Column — the specific column, where the type needs one (Column, Source Lookup, Reference Value).
  • Status — Active, Draft or Unmapped for this field.

Steps to map a field

  1. Find the target field's row in the grid.
  2. Click the Edit icon (pencil) on that row to put it into edit mode.
  3. In the Type column, choose the map type (the six types are explained below).
  4. Fill in the Source (and Source Column) the way that type requires.
  5. Set the field's Status to Active when it's ready (or leave it Draft for now).
  6. Click into another row, or press the row's confirm control, to save. Changes are saved as you go.

To map a field to more than one source, or to add a source column that only exists on a child table, click the Add icon on the row — this creates an extra row under the same target that you can map independently. To remove a mapping row, click the Delete icon on it.

You work through the rows until every field that needs a value has one and the Unmapped count reaches zero (or as close as the object requires).

5.1 The six map types​

Every mapped field is one of six map types. Choosing the right type is the heart of mapping, so here is each one — what it's for, and how to fill it in.

TypeUse it when the target value…What you enter in the grid
Columncomes straight from one column of your main source data.Pick the Source Table, then the Source Column.
Source Lookupcomes from a related source table, fetched by looking it up.Pick the Source Table to look in, then the Source Column to return.
Reference Valuecomes from OnCoor reference data (a conformed lookup list).Pick the Reference, then the Reference Column to return.
Formulais calculated — trimmed, combined, reformatted, or conditional.Open the Formula Builder and build the expression or CASE logic.
Reusable Functionis produced by a saved function your team maintains.Pick the Reusable Function from the list.
Static Valueis a fixed constant that's the same for every row.Type the value directly into the cell.

How to maneuver each type

  • Column — the everyday case: a direct copy. Set Type = Column, choose the Source Table, then choose the Source Column from that table. The value is carried across as-is.

  • Source Lookup — use this when the value isn't in the row you're mapping but in another source table you need to look into. Set Type = Source Lookup, choose the Source Table to look in, then the Source Column to bring back. (It's filled in just like Column — the difference is the intent: a lookup into related source data rather than a straight copy.)

  • Reference Value — use this to pull a value from OnCoor's reference data rather than from the source. Set Type = Reference Value, pick the Reference from the dropdown (only top-level references appear here), then pick the Reference Column to return. For anything that needs a join key or a more complex match, set the reference up first in the Reference Join Map — this type then points at it.

  • Formula — use this whenever the value needs work: trimming, concatenation, date reformatting, or if/then logic. Set Type = Formula and the Source cell opens the Formula Builder, where you build an Expression or a Case using your source columns, operators and functions. See Transform Mappings and the Formula Builder.

  • Reusable Function — use this when the same calculation is standardised across mappings and has been saved as a reusable function. Set Type = Reusable Function and pick the function from the editor; you don't rebuild the logic each time.

  • Static Value — use this for a hard-coded constant — a flag, a fixed code, a default the target always needs. Set Type = Static Value and simply type the value into the cell. There's no source column, because the value doesn't come from anywhere else.

DRAFT LETS YOU SAVE A HALF-FINISHED ROW — OnCoor only enforces a type's required fields once the field is marked Active. While a field is Draft, you can pick a type and come back to fill in its source later. A field left Unmapped is skipped entirely. So the workflow is usually: set the type, mark it Draft while you gather details, then switch it to Active once the source is filled in.

EDITING IS LOCKED ONCE SUBMITTED — You can only change a mapping while its version is Open. If the version is Pending or Approved, the grid is read-only until it's reopened. If you don't have edit permission, it's read-only for you too.

6. Auto-Map and AI Suggestions​

Rather than map every field by hand, you can ask OnCoor to propose the mappings and then review them. This is Auto-Map. It compares your source columns to the target fields, scores how closely each pair matches, and fills in the ones it's confident about.

6.1 The Threshold Score​

Auto-Map is governed by two numbers you can adjust:

SettingDefaultWhat it does
AutoMap Minimum92Matches scoring at or above this are mapped automatically.
Review Minimum75Matches scoring between the two numbers are proposed for you to review. Anything below the Review Minimum is left unmapped.

So a higher AutoMap Minimum means OnCoor only maps the near-certain matches on its own; lowering it lets it map more but with less certainty. The Review Minimum sets the floor for what's even worth showing you.

THE ONE RULE — The Review Minimum must be lower than the AutoMap Minimum. OnCoor won't let you run the auto-map until that's true.

6.2 Running it​

Steps

  1. Start the auto-map:
    • For a new mapping — tick Auto-Map in the Add Mapping dialog before saving.
    • For an existing mapping — open it, click the More (…) button in the toolbar, and choose Re-map / Auto-map.
  2. Choose the source to match against and, if needed, use the assign-source step to say which source tables pair with the target.
  3. Adjust the AutoMap Minimum and Review Minimum if the defaults don't suit (remember: Review Minimum must be lower than AutoMap Minimum). If you're re-running, click Re Auto-Map to apply the new thresholds.
  4. OnCoor shows the proposed matches in a confirmation screen. Review them, deselect or change any you disagree with, then apply to write them into the grid.

6.3 AI Suggestions​

Where your environment has AI switched on for the layer, the confirmation screen also offers a Get AI Suggestions button. This asks the AI model for its best matches for the fields still in question, each with a confidence score and a short reason, so you can pick the right target with more context than a name-similarity score alone. You stay in control — nothing is applied until you choose it.

AI HAS TO BE ENABLED FIRST — AI Suggestions appear only when AI is switched on for this data domain and suggestions are permitted. That's controlled in the AI Module. See the Data Domain Policies guide for turning on Suggestions for a domain.

7. Transform Mappings and the Formula Builder​

When a target field isn't a straight copy — it needs trimming, reformatting, combining, or conditional logic — you map it with a formula. The Formula Builder lets you build that logic visually, without writing raw SQL, using your source columns, a set of operators, and a library of functions (including reusable functions your organisation has set up).

The builder works in two modes, which you switch between at the top:

  • Expression — build a single calculated value, for example trimming a code or concatenating two columns.
  • Case — build conditional (if / then) logic: return one value when a condition is met, another otherwise, with as many cases as you need.

Steps

  1. In the target field's row, open the Formula Builder.
  2. Choose Expression or Case.
  3. Drag in or select the source fields you need (use Add Field to bring in more), then combine them with operators and functions.
  4. Confirm the formula. It's saved against the field and the mapping is updated.

REUSABLE LOGIC — If the same calculation shows up across many mappings, it's worth saving it as a reusable function so you can drop it in rather than rebuild it each time.

8. Value Mapping​

A transform changes the shape of a value; value mapping changes the value itself according to a lookup you define. It answers cases like: the source stores a status as 1, 2, 3, but the target expects Active, Closed, Pending. You define those pairings once as a value map, and OnCoor applies them during conversion.

Value mapping has its own dedicated guide, which covers building a map (authored values or reference crosswalk), filling in the values, handling unmatched values, and importing or exporting in bulk. Rather than repeat it here, see the Value Mapping guide.

How it connects to the Mapping Manager. Once a value map exists, you use it on a field by mapping that field with a type that draws on it (a Reusable Function or a reference crosswalk). Where a field is already backed by a value map, a small Value Mapping icon appears on its grid row — click it to see the map's details in place.

WHEN TO REACH FOR IT — Use value mapping for coded values and short lookup lists that translate one set of allowed values into another. For anything driven by a full reference table, use Reference Data Mapping instead.

9. Reference Data Mapping​

Sometimes a target value has to be looked up from a reference table rather than taken from the source. For example, the source gives you a part number and you need the matching category from a reference list. This is reference data mapping, and it comes in two forms.

Reference Map. Point a target field at a column in a reference table, so its value is pulled from there.

Reference Join Map. For richer cases, join a source column to a reference table on a matching key and return a chosen column from it — optionally shaping the join key with a value expression (for example LEFT(PART, 10)). The join map dialog lets you build these joins, add several at once, and view their history.

Validation. Reference mappings have to be complete to work. If any are left half-finished, OnCoor raises "Invalid Reference Mappings Detected" and lists exactly which items still need their column mapping filled in, so you can finish them.

Steps — point a field at reference data

  1. In the grid, click Edit on the target field's row.
  2. Set Type = Reference Value.
  3. In the Source cell, pick the Reference from the dropdown.
  4. In the Source Column cell, pick the Reference Column to return.
  5. Set the status and save the row.

Steps — set up a reference join (key match)

  1. Open the Reference Join dialog from its icon in the toolbar.
  2. Click Add to create a join row.
  3. Choose the reference table, and set the key that links your source to it. Use the expression editor to shape the key if you need to (for example LEFT(PART, 10)).
  4. Add more join rows if the match needs several conditions.
  5. Save. The reference is now available to pick as a Reference Value on a field.

If validation flags something. When you save, OnCoor checks that every reference mapping is complete. If any are unfinished it shows "Invalid Reference Mappings Detected" with the exact items listed — open each one, fill in its missing column, and save again.

10. Configuring the Template and the Grid Columns​

10.1 Configure Template​

Each mapping carries a few settings of its own — its name, its source, its queue, and its dates. The Configure Template page is where you review and update these after the mapping has been created.

Steps

  1. Open the mapping.
  2. Click the Configuration (gear) icon in the toolbar. This opens the Configure Template page.
  3. Update the name, source, queue or dates as needed.
  4. Save, then use the back control to return to the grid.

10.2 Reconfigure Columns​

The grid can show many columns, and not every team wants to see all of them. Reconfigure Columns lets you decide which columns appear, what order they sit in, and lets you add custom columns to capture extra information your process needs.

This works at two levels:

  • Domain default — the standard column layout for every mapping in the domain.
  • Per-mapping override — a custom layout for just this one mapping. You can override the default and, if you change your mind, reset back to the domain default at any time.

Steps

  1. Open the mapping and click the Configuration (gear) icon in the toolbar.
  2. Switch to the Columns / Reconfigure tab.
  3. Show or hide columns with their checkboxes, and use the arrows to move them into the order you want.
  4. Choose whether you're editing the domain default (applies to every mapping in the domain) or overriding this mapping only. If you've overridden a mapping and want to go back, use Reset to return it to the domain default.
  5. Save. The grid, and any Excel export or import, will use the columns you've set.

10.3 Adding a custom column​

Beyond the built-in columns, you can add your own — up to six — to capture extra information your process needs (a review note, an owner, a pick-from-a-list flag, a target date). Custom columns behave like any other grid column: they show in the grid and travel through Excel export and import.

Steps

  1. On the Columns / Reconfigure tab, click Add Custom Column. The Configure Custom Columns dialog opens.

  2. Click + Add Custom Column to open the next available slot (you get six in total).

  3. Fill in the column:

    FieldWhat to set
    ActiveTick this to switch the column on so it appears in the grid.
    Column NameThe heading shown on the grid column.
    TypeThe kind of value it holds — String (free text), Long (a whole number), Pick List (choose from a fixed set of options), or Date.
    ValuesOnly for a Pick List — type the allowed options separated by commas (for example Low, Medium, High).
    Allow empty optionOnly for a Pick List — tick this to let the column be left blank as well.

  4. Add more custom columns the same way if you need them (up to the six-slot limit).

  5. Click Save. The new columns appear in the grid straight away; to hide one later, untick its Active box.

PICK LISTS KEEP DATA CLEAN — If a custom column should only ever hold a set list of values, choose Pick List and type the options. Users then choose from a dropdown instead of typing free text, which keeps the values consistent.

11. Search, Notes, History and Data Relevancy​

Search narrows the grid to the rows you're after — handy on large objects with hundreds of fields.

Steps

  1. In the search box above the grid, type a target table or column name.
  2. The grid filters as you type. Clear the box to show everything again.

11.2 Notes​

Each mapping has a Notes panel for recording decisions and context, with a full history of note changes so the reasoning travels with the mapping.

Steps to add or edit a note

  1. Open the mapping (make sure a version is selected).
  2. Click the Notes icon in the toolbar. The notes panel opens.
  3. Click Edit (or the "add a note" link if there's no note yet).
  4. Type your note. Use the formatting buttons for bold, italic, underline, and bulleted or numbered lists.
  5. Click Save. Your note is stamped with your name and the date.

To see the note's history, expand the History section inside the same panel — it lists each Created, Edited and Deleted entry with who made it and when; click an entry to see what the note said at that time. You can drag the panel's edges to resize it.

11.3 History and restoring a change​

The Audit History is the full trail of the mapping — what changed, when, and by whom — and it's where you roll a change back.

Steps to view history and restore

  1. Open the mapping, click the More (…) button in the toolbar, and choose Audit History.
  2. Browse the changes. Use Expand to open a change and see its line-by-line detail, including deleted items.
  3. To undo a change, find the earlier state you want and click Restore. The mapping returns to how it was at that point.

For a single field's history, you don't need the full page — click the History icon on that field's row in the grid to see just its changes.

11.4 Data Relevancy​

Not every source row belongs in a mapping. Data relevancy lets you set filters that limit which source rows count for a given source table (for example, only rows where a status column equals a certain value).

Steps

  1. In the grid, find the source-table group header (the heading that groups the rows coming from one source table).
  2. Click the filter icon on that header. A focused panel opens showing only that table's relevancy filters.
  3. Click Add filter, choose the column to filter on, and set the value(s) it must match. Each column can be filtered only once per source table.
  4. Add more filters if needed; use the delete (X) on a row to remove one.
  5. Save your changes:
    • Apply saves and keeps the panel open.
    • Save & Close saves and closes the panel.
    • Discard reverts to how the filters were when you opened it.

THE AUDIT TRAIL IS ALWAYS ON — You don't have to switch history on; every change is recorded automatically. That's what makes Restore safe to rely on.

12. Importing and Exporting a Mapping​

For bulk edits, offline review, or handing a mapping to someone who prefers a spreadsheet, you can move a whole mapping in and out of Excel.

Export. Export downloads the current mapping as an Excel workbook named after the mapping. The workbook has separate sheets for the mapping itself plus supporting lookup, source, target and reference sheets, so the file is self-describing.

Import. Import reads a filled-in workbook back into the mapping. OnCoor checks the source columns as it goes and warns you about anything that doesn't line up, so a bad row is caught rather than silently loaded.

Steps

  1. Use Export to download the mapping as .xlsx.
  2. Edit the mapping rows in the workbook, keeping the column headings intact.
  3. Use Import, choose your file, and review any warnings before confirming.

KEEP THE COLUMNS INTACT — Import matches on the column headings in the workbook, and those follow whatever you set in Reconfigure Columns. If you've changed the grid's columns, export a fresh copy to edit rather than reusing an old file.

13. The Mapping Detail Tabs​

When you open a single mapping in detail, its work is organised into tabs across the top — click a tab name to switch to it. The first few are the Mapping Manager's own; the last three surface other OnCoor modules in place, so you can move from mapping a field to defining its rules and checking the results without leaving the screen.

TabWhat it's for
Field MappingThe main grid covered throughout this guide — mapping each target field.
Ref ConfigThe reference-data configuration for the mapping (see Reference Data Mapping).
Value MappingSource-to-target value translations for the mapping (see Value Mapping).
RulePilotThe data-quality rules for this object. This is the Rule Pilot feature shown here for convenience.
ETLThe data-generation / ETL surface for the object — the same workspace used elsewhere for Enterprise Objects.
Pre-Load ReportsValidation reports that check the data before it's loaded.

THESE LAST THREE ARE THEIR OWN FEATURES — RulePilot, ETL and Pre-Load Reports are separate OnCoor modules embedded here as tabs. This guide covers how they fit into a mapping; for the full detail of each, see that module's own documentation.

14. Mapping Manager vs. the AI Mapping Workbench​

OnCoor has two places that mention "mapping", and it's worth knowing which is which.

  • The Mapping Manager (this guide) is your everyday, layer-by-layer mapping workspace under Management. You pick an object, open its grid, and map its fields — with Auto-Map, formulas, references, versions and approvals. It's the tool you live in while building and maintaining mappings.
  • The Mapping Workbench is a newer, AI-led tool in the Discovery Module. It pairs a whole source system to a target model, works pair-by-pair with AI proposing matches, and then promotes a drafted plan forward into your conversion tooling. It's aimed at the earlier, exploratory job of figuring out a mapping from scratch.

A rough rule of thumb: use the Mapping Workbench to discover and draft a mapping from a source you don't know well; use the Mapping Manager to build, refine, version and approve the mappings you run day to day. See the Mapping Workbench guide for that tool.

15. Quick Reference​

A fast lookup for the most common actions.

I want to…Do this
Open the toolManagement → Mapping Manager
Start a new mappingLeft panel → pick layer → Add Mapping → choose object, name, source → Save
Load an existing mappingPick the layer, then click the object in the left-panel tree
Copy a value straight from sourceType = Column → pick Source Table + Source Column
Pull a value from a related source tableType = Source Lookup → pick Source Table + Source Column
Pull a value from reference dataType = Reference Value → pick Reference + Reference Column
Build a calculated valueType = Formula → open the Formula Builder (Expression or Case)
Use a saved functionType = Reusable Function → pick the function
Set a fixed constantType = Static Value → type the value in the cell
Translate coded valuesSee the Value Mapping guide, then use the map via a Reusable Function / crosswalk
Set up a reference join/keyUse Reference Join Map, then point a Reference Value field at it
Let OnCoor propose the mappingsTurn on Auto-Map (or Re Auto-Map), set the thresholds, review, apply
Get AI-assisted matchesIn the auto-map review, click Get AI Suggestions (needs AI enabled for the domain)
Change the visible grid columnsConfiguration → Columns / Reconfigure (domain default or per-mapping)
Add a custom grid columnColumns / Reconfigure → Add Custom Column → set name, type, values → Save
Prepare a future changeAdd a new version with an effective date
Send a mapping for sign-offSubmit for Approval → an approver Approves or Denies
Reopen a denied/approved versionReopen it to make edits
Edit offlineExport to Excel, edit, then Import
Undo a changeHistory → Restore the earlier state
Limit which source rows countClick the filter icon on a source-table header → set relevancy

Source: OnCoor product documentation, written for end users. For the latest screens and options, always refer to the in-app interface.