Mapping Workbench
Feature Guide — Mapping a Source System to a Target Model, Pair by Pair
Module: Discovery Module › Mapping Workbench | Last updated: August 2026
Contents
- Overview
- Finding Your Way Around
- Starting a Mapping
- The Workspace Layout
- Match Threshold and Auto-Approval Limit
- Generating Suggestions
- Reviewing Pairs
- Per-Pair Detail — Transform, Tests and Rule
- Reference Data
- Modeling in the Platform
- Promoting the Mapping
- Resuming and Sharing
- Quick Reference
1. Overview
The Mapping Workbench turns the slow, manual job of mapping one system's data to another into a guided, AI-assisted plan. You pair a source business object (for example, a legacy Baan/LN object) with a target business object (for example, an SAP object) and work through them one table-pair at a time. For each pair, AI proposes which columns match, scores how confident it is, explains why, and flags what genuinely can't be mapped. For each match you accept, it drafts the transformation logic, a validation rule and test cases — then promotes the whole plan into your conversion tooling as reviewable drafts.
Like the rest of the Discovery Module, it follows AI proposes, a human disposes: every suggestion is reviewed by you, and every promotion lands as a draft that a person must approve before anything goes live. And it's never blocked by AI — if the AI service is unavailable, it still suggests matches (by similarity), still drafts transforms (from a pattern library), and still promotes.
What you can do here
- Pick a source and target business object and derive the table pairs to map.
- Auto-suggest column matches with a confidence score and a plain-language reason.
- Accept, modify, reject or bulk-approve matches.
- Generate transforms, tests and validation rules for each accepted match.
- Reconcile check tables (Countries, Currencies, …) into reference configs.
- Promote everything as drafts into Conversion Mapping, Rule Pilot and Reference Configurations, and export the test suite as Excel.
WHERE TO FIND IT — The Mapping Workbench has its own left-nav entry. It appears only for users granted the Use Mapping Workbench permission.
IT PAIRS NICELY WITH DISCOVERY — You can launch it straight from a Discovery session, and it inherits that session's readiness score and findings for context. See Starting a Mapping.
2. Finding Your Way Around
When you open the workbench you're on the start screen, where you resume a saved mapping or start a new one.
Once a mapping is active, the screen is a dual-model workspace:
- A pair queue rail listing every table pair to map, so you can switch between them.
- The match suggestions for the active pair, where the actual mapping is reviewed.
- A toolbar with the thresholds, the deterministic and AI run buttons, and a Configuration reveal.
- Optional Source and Target column panels (opened with View columns) showing the active pair's columns.
- A Reference Data panel and a Promote area for landing the finished plan.
The page subtitle always shows what you're mapping — target business object ← source business object — so you know which direction you're working in.
3. Starting a Mapping
Starting a new mapping happens on the new-mapping screen, which has three areas top to bottom: a Target panel and a Source panel side by side, and — once you've picked a target — a Table-pair queue beneath them. The workbench is target-driven: you choose what you're mapping to, and it works out the source side and the tables involved. Work through the areas in order.
Step 1 — Set up the Target
In the green Target panel:
| Field | What to set |
|---|---|
| Target system | The system you're mapping to (for example, SAP). It defaults sensibly, but you can change it. |
| Target business object | The object you're mapping to — start typing to search. The number in brackets is how many tables it has. This is the required choice that kicks everything off. |
| Industry scope | Optionally narrow the tables to core objects only, or core plus one industry (Beverage, Utilities, and so on). |
| Target layer | Where the target model and mapping land — Conversion (the default, for source-to-target migrations) or Cleansing. |
| Enable Integration Framework | Optionally apply a framework (for example, SAP Activate). When on, modeling the target later marks the object and its tables in scope. Pick the specific Framework underneath. |
Step 2 — Confirm the Source
In the blue Source panel:
| Field | What to set |
|---|---|
| Source system | The system you're mapping from (for example, Baan/LN). It defaults to a likely source system. |
| Source business object | Auto-matched — once you pick the target, the workbench selects the same-named source object for you. Override it if the match isn't right. |
| Source feed | Where the source data comes from — From Cleansing layer (a prior conform layer) or From external source (connection). A Cleansing target is always fed from an external source. |
| Source connection (optional) | Only needed to Model in platform (so field mappings and rules can promote) and for live-data preview. Mapping from the catalog works without it. |
Step 3 — Review the Table-pair queue
As soon as a target business object is chosen, the Table-pair queue appears. This is the heart of the setup: the workbench pairs each target table with its best-matched source table(s) — these pairs are what you'll map one at a time in the workspace. Each row shows:
- A checkbox — whether the pair is in scope. Untick to exclude a target table you don't want to map; excluded pairs are kept but hidden from the workspace. Use Select all / Clear to include or exclude everything at once.
- Target table — its business name with the underlying table code beneath.
- Membership — the business-object groups the table belongs to, as chips. A shared table like Address shows under both Customer and Supplier, so you can see where it's reused.
- Source table(s) — add or change — the matched source table(s). An auto-matched table appears as a green chip with its match percentage; you can remove it, or add more source tables (a target can be fed by several). Below the box, Suggested: chips list AI-proposed source candidates with their match score — click one to add it.
A chip near the top shows how the tables were matched — ✨ AI + name match (AI embeddings blended with name similarity) or Name match (AI off) (name similarity only) — alongside counters for how many pairs are in scope and how many are matched.
Step 4 — Start mapping
The action bar pinned at the bottom summarises the setup (target → source · N tables matched). Click Start mapping — enabled once at least one table is in scope — to open the workspace and begin mapping columns.
Alternative — Launched from Discovery
Instead of setting this up by hand, you can launch the workbench straight from a Discovery session. A banner then shows Launched from Discovery #N with the inherited readiness score and how many findings carried over, so the mapping begins with that context already in hand.
4. The Workspace Layout
Once you click Start mapping, the workbench opens the workspace — where the actual column-by-column mapping happens. Where the new-mapping screen was about choosing which tables to map, the workspace is about mapping the columns within one table pair at a time. Down the page there's a header bar, a pair-queue rail on the left, and the mapping area (search, table KPIs and the match suggestions) on the right. Its parts are described below.
4.1 The header bar
The header shows what you're mapping (target ← source) and a chip with how many table pairs are in scope. It also carries two buttons:
- Change objects — Clears the current selection and returns you to the new-mapping screen so you can pick a different target and source to map. Use it when you want to map something else; your saved session isn't lost, you're just starting a fresh selection.
- Edit table pairs — Opens the pairing editor (below). The button reads Close editor while it's open.
4.2 Editing table pairs
Edit table pairs lets you change the (target ↔ source) pairs of the current session without starting over. For each target table you can add, remove or re-point its source table(s), choosing from every table in the source system — with the same AI/name Suggested candidates and match scores you saw on the new-mapping screen — and you can include or exclude targets from scope. Click Save to apply the changes to the session, or Cancel to discard them. Excluded pairs stay saved but drop out of the rail.
4.3 Source and Target column panels
By default the workspace shows the match suggestions, not the raw columns. Click View columns to reveal the Source and Target column panels side by side for the active pair; click Hide columns to collapse them again. Each panel lists the table's columns in three columns:
- Attribute — the column's business name with its technical name beneath. Hover the name to see its full description as a tooltip (there's no separate description column).
- Type — the data type.
- Key — markers for primary key (PK), foreign key (FK) and not-null (NN).
When a pair is multi-source (more than one source table feeds the target), a source panel is shown for each source table. Use this whenever you want to see the full column detail behind a match.
4.4 Pair-queue rail
The rail on the left lists the in-scope table pairs (the ones you kept in scope when starting, as edited above). Click a pair to make it the active pair. Each entry shows status chips for whether its deterministic and AI passes have run, so you can track progress across the whole object — and you can run a table's passes straight from the rail.
4.5 Search and table KPIs
Above the suggestions, a search box filters the active pair's matches by source or target column or business name, and a small KPI strip summarises the active target table (how many columns are matched, accepted, and so on).
4.6 AI helpers legend
A one-line AI helpers key sits above the suggestions and decodes the small icons shown on each match row. They fall into two groups:
- Understanding a match (blue): Match fields, Confidence, Reason, Flagged (unmappable).
- Generated artifacts (green): Transform, Rule, Tests, Reference.
An icon lights up on a row once that helper has produced something for it, so you can see at a glance which matches already have a reason, a transform, a rule, tests, and so on.
4.7 Configuration
Expand Configuration in the toolbar to review or change the choices you made when starting — Target layer, Source feed, Source connection and Framework — without leaving the workspace. Connections are flagged by whether their source actually contains the object. The toolbar also holds the two thresholds and the run buttons, covered in Match Threshold and Auto-Approval Limit and Generating Suggestions.
5. Match Threshold and Auto-Approval Limit
Two sliders in the toolbar control how matches are treated, and each is remembered per table:
| Control | What it does |
|---|---|
| Match threshold | The "mappable floor." Any column pair scoring below this is flagged unmappable rather than offered as a match. Raise it to be stricter about what counts as a real match. |
| Auto-approval limit | The floor for bulk approval. When you bulk-approve, every pair scoring at or above this limit is accepted in one go. |
Changing a table's match threshold marks its suggestions stale, so you can re-run to reflect the new floor.
6. Generating Suggestions
Before you can review any matches, you have to generate the suggestions. The workbench proposes column matches in two passes:
| Pass | What it does |
|---|---|
| Deterministic | The free, fast pass. Matches columns using name, type and key rules only — no AI. This is the baseline. |
| AI | The AI boost. Blends embeddings for higher-quality matches, on top of the deterministic baseline. |
To generate suggestions for one table
- Select the table pair in the pair-queue rail.
- Click Det on that rail entry to run the deterministic pass. The button shows a green tick once it's current.
- Click AI to run the AI boost. (If the deterministic baseline hasn't run yet, AI runs it first automatically.)
To generate suggestions for every in-scope table at once
Use the toolbar buttons: Run deterministic (all) runs the deterministic pass on every table that still needs it, and Run AI (all) runs the AI boost on every table that has a baseline and still needs AI.
Either way, the matches then appear as suggestion cards for the active pair, ready to review. While the AI pass runs, a progress panel shows what it's doing — embedding columns, writing plain-language reasons, then scoring matches.
A TABLE NEEDS A SOURCE FIRST — The Det and AI buttons only work once a table pair has at least one source table. If a target has no source, add one in Edit table pairs first.
AI BUILDS ON THE DETERMINISTIC BASELINE — Run deterministic first (or let a table's baseline exist), then run AI to boost it. The AI pass only runs for tables that already have a deterministic baseline and still need it. Columns scoring below a table's match threshold are flagged unmappable either way.
7. Reviewing Pairs
Each proposed match is a suggestion card in the pair list, split into Mapped and Unmappable groups (partitioned live against the current match threshold). A card shows:
- The source column and the target attribute it's matched to.
- Confidence chips — the deterministic score, the AI score, and the blended score used for decisions.
- A plain-language explanation of why they match (hover to read it).
- Small indicators for whether a transform and a rule have been generated yet.
- For unmappable rows, a chip showing it's below threshold and the reason kind.
The decision buttons appear on each card once suggestions have been generated (Generating Suggestions) — before that, there's nothing to decide on. On a still-undecided mapped row you'll see:
| Action | What it does |
|---|---|
| Accept | Confirms the match. |
| Modify | Re-points the match to a different target attribute. |
| Reject | Discards the match. |
A few things to know about when these show:
- Unmappable rows (below the match threshold) only offer Modify — there's nothing to accept or reject until you re-point them to a real target.
- Once you decide, the buttons are replaced by a status chip (Accepted, Modified or Rejected) showing what you chose. To change your mind, re-point with Modify.
- Details is not shown until a row is Accepted or Modified. After you accept a match, a Details button appears — that's how you open its transform, tests and rule (see Per-Pair Detail).
To move quickly, use bulk approve to accept every pair at or above the auto-approval limit in one action, then review the rest by hand.
8. Per-Pair Detail — Transform, Tests and Rule
Once you've accepted or modified a match, a Details button appears on its card. Expanding Details reveals three tabs, each of which drafts something you can promote later:
Transform — The transformation logic that converts the source value into the target. It's offered as both SQL and Python, tagged with the pattern it used and whether it came from AI or the pattern library. Use Generate transform (or Regenerate) to (re)create it.
Tests — A set of unit test cases for the transform, each labelled with its kind, so the mapping can be verified.
Rule — A suggested validation rule for the mapped data, with its quality dimension and severity. It's marked → Pending Review (AI), meaning it will land in Rule Pilot's review queue when promoted. Use Generate rule (or Regenerate) to (re)create it.
Everything drafted here is a proposal — nothing is applied until you promote it and approve it downstream.
9. Reference Data
Systems store many values as codes — countries, currencies, units of measure — and the source system's codes rarely match the target's. The Reference Data panel in the workspace builds a crosswalk that translates a source code list into the target's, so migrated data lands with valid target codes. It has its own Import check-table button, and a How this works explainer you can expand. The flow has three stages.
9.1 Bring code lists into scope (Import check-table)
The pickers only offer code lists that are in scope. On real tenants these arrive automatically from the metadata harvester; otherwise, bring one in with Import check-table. In the dialog:
- System side — whether this list belongs to the Source or Target system.
- Domain name — the name the list appears under in the pickers (for example, Countries).
- Choose where the codes come from:
- From a source table — pick a table on that side's connection, then its Code column and an optional Label column.
- From a file (CSV/XLSX) — choose a file; the workbench reads its headers so you can pick which column is the code and which is the label.
- Click Import.
Repeat for each side you need — for example, import the Baan units as a Source list and the SAP codes as a Target list.
9.2 Generate the crosswalk
- Pick a Source code list — the codes you're translating from.
- Optionally pick a Target code list (optional) — the codes you're reconciling to. Leave it as none to keep the source codes.
- Click Generate draft.
The draft appears as a table of Source → Target rows with the target's label, above chips showing it's a Draft, how many source codes matched a target, and whether it was reconciled deterministically or with AI. Any source code with no target match is tagged unmatched so you can see the gaps.
9.3 Promote the value mapping
With a draft in hand:
- Promote as Value Mapping (recommended) — Creates a governed value mapping and wires it onto the conversion mapping line for the target column, so during conversion each source code is translated to the valid target code. Small curated sets become an editable function; large code sets become a reference crosswalk resolved by a join (no row cap).
- Onboard as standalone Reference Config — A secondary option that builds a standalone, reusable reference object without wiring it to a mapping line. Rarely needed, especially for small sets.
Reference configs are also one of the artifacts you can include in the main Promote step.
WHY IT MATTERS — Without a crosswalk, a migrated record can carry a code the target system doesn't recognise. The value mapping makes sure each source code lands as a valid target code.
10. Modeling in the Platform
Some promotions — the field mappings and validation rules — can only be created once the source object is modeled in the platform (i.e. has been through Intake so it has its business attributes and conform-data). If it hasn't, the workbench offers a Model in platform action that models the object from the session's source connection and object (defaulting to the Cleansing layer), reusing the same bridge as the Discovery Workbench.
If you promote before modeling, the workbench doesn't fail — it simply skips the field mappings and rules with a note, and still promotes everything else (reference configs and the test suite promote either way).
11. Promoting the Mapping
When you're happy with the reviewed mapping, the Promote step lands it forward as drafts. Choose what to include:
| Include | Where it lands | As |
|---|---|---|
| Field mappings | Conversion Mapping | A draft mapping (status Open) |
| Transforms | Conversion Mapping | Attached to the field mappings |
| Validation rules | Rule Pilot | Pending Review (AI) |
| Reference configs | Reference Configurations | Custom drafts |
| Test suite (xlsx) | Downloaded to your computer | An Excel workbook |
Click Promote to create the selected artifacts, and Download test suite to save the test bundle as Excel. Each promoted artifact carries lineage back through the mapping session to where it came from.
EVERYTHING LANDS AS A DRAFT — Field mappings land Open, rules land in the Pending Review (AI) queue, reference configs land as custom drafts. Nothing goes live until a person reviews and activates it in its home module.
PROMOTE DEGRADES GRACEFULLY — If the target isn't fully modeled or resolved, the workbench skips just the parts that need it (field mappings, rules) with a note, rather than failing the whole promotion.
12. Resuming and Sharing
Every mapping is saved as a session, and your saved mappings appear on the start screen to resume. Sessions remember your per-table decisions, the deterministic/AI status of each table, your promote summary and any drafts — so you can pick up exactly where you left off.
Sessions are reachable by a deep link and are shareable across your tenant, so a colleague who opens the link sees the same review state. Mapping data and the AI learning store stay private to your tenant.
IT LEARNS AS YOU GO — Accepted mappings feed back into the suggestion engine, so its recommendations improve as your team works through more objects.
13. Quick Reference
A fast lookup for the most common actions.
| I want to… | Do this |
|---|---|
| Start a new mapping | Start screen → pick a target business object → Start mapping |
| Continue from Discovery | Launch the workbench from a Discovery session (inherits its context) |
| Resume saved work | Start screen → pick a saved mapping |
| Change layer, source feed or connection | Toolbar → Configuration |
| Map a different target/source | Header → Change objects |
| Add, remove or re-point a pair's source tables | Edit table pairs → adjust → Save |
| See the raw source/target columns behind a match | View columns |
| Decode the per-row AI icons | Read the AI helpers legend above the suggestions |
| Get column-match suggestions (free) | Run deterministic (all), or per table in the rail |
| Improve matches with AI | Run AI (all), or per table in the rail |
| Accept a match | On its card → Accept |
| Point a match at a different attribute | On its card → Modify |
| Accept everything above the limit | Set the Auto-approval limit → bulk approve |
| Draft transform / tests / rule for a match | Expand the card → Details → the tabs |
| Bring a code list into scope | Reference Data → Import check-table (source table or CSV/XLSX) |
| Translate source codes to target codes | Reference Data → pick Source / Target code list → Generate draft → Promote as Value Mapping |
| Enable field-mapping / rule promotes | Model in platform |
| Land the plan as drafts | Promote → choose what to include |
| Export the test cases | Download test suite |
| Share the mapping | Send the session's deep link to a colleague |
Source: OnCoor Discovery Module product documentation, written for end users. For the latest screens and options, always refer to the in-app interface.