Implementation Framework
An Introduction — Running a Structured Data Conversion in OnCoor
| Last updated: September 2026
Contents
- Overview
- The Two Halves: Blueprint and Project
- The Building Blocks
- How a Conversion Actually Runs
- Who Does What: Owners
- Where to Find Everything
- Quick Reference
1. Overview
Moving data from old systems into a new one — a data conversion (also called a migration) — is rarely a single step. It happens in stages, involves many people, stretches over weeks or months, and has to be tracked object by object so nothing is missed. OnCoor's Implementation Framework is the part of the product that gives that work a shape: a clear set of phases to move through, a list of exactly which data objects are being converted, named people accountable for each part, and a live view of how far along everything is.
The Implementation Framework comes in two connected parts, and understanding how they relate is the key to everything else:
- The blueprint — you define how a conversion should run: the phases, the steps within each phase, and the roles involved. You set this up once, and reuse it for every conversion.
- The project — you then run a conversion against that blueprint: choose which data to convert, assign the people, set the dates, and track progress as the work moves through the phases.
WHERE TO FIND IT — The blueprint lives in the Implementation Framework Configuration page (a page of tabs: Framework, Phase, Sub Phase, Owner Type):
- Left navigation menu → Pipeline Configuration → Implementation Framework
- or Management → Config → Implementation Framework
Running a conversion happens in the Implementation Framework module (formerly the Conversion module):
- Left navigation menu → Process → Implementation Framework
- or Management → Conversion
Both are named "Implementation Framework" — the blueprint sits under Pipeline Configuration, the running conversion under Process.
What the Implementation Framework gives you
- A repeatable method — define your conversion approach once and reuse it, instead of reinventing the process each time.
- A single scope list — one place that records exactly which data objects are being converted.
- Clear accountability — every object and every step has named owners.
- A live picture of progress — see at a glance which phase you're in, what's on track, and what's slipping.
2. The Two Halves: Blueprint and Project
It helps to keep the two halves clearly apart in your mind. One is the template; the other is the live work.
| The Blueprint (Config) | The Project (Conversion) | |
|---|---|---|
| What it is | The reusable method — the phases, steps, and roles | An actual conversion in progress, following that method |
| Think of it as | The recipe | Cooking the meal |
| You set it up in | Pipeline Configuration → Implementation Framework | Process → Implementation Framework |
| How often you touch it | Rarely — set once, adjust occasionally | Continuously, throughout the conversion |
| Who works here | An administrator or lead who owns the method | The whole conversion team |
Rule of thumb: if you're deciding how a conversion should be structured, you're in the blueprint. If you're doing the day-to-day work of a specific conversion, you're in the project.
The two are joined automatically. When you run a conversion, it follows the blueprint that has been set as your data domain's default framework — so the phases and steps you see while working are exactly the ones defined in the blueprint.
3. The Building Blocks
The blueprint is built from a small set of pieces that fit together in a simple hierarchy.
| Building block | What it is | Example |
|---|---|---|
| Framework | The whole method for a conversion, top to bottom. A conversion follows one framework. | "S/4HANA Data Conversion" |
| Phase | A major stage within the framework, done in order. | Envision → Discover → Build → Cutover |
| Sub Phase | A step within a phase — this is where the actual work screens live. | "Set Scope", "Cleansing", "Mock Load 1" |
| Owner Type | A kind of role that people are assigned to. | Data Owner, Functional Lead, Approver |
The first three nest inside each other: a Framework contains Phases, and each Phase contains Sub Phases. Phases and sub-phases each have a sequence number, which fixes the order they appear in.
Owner Types sit alongside this structure rather than inside it. They're the roles — and for each sub-phase, the blueprint records which roles are Responsible for the work and which are Approvers of it.
YOU DON'T START FROM SCRATCH — OnCoor typically arrives with a standard framework already defined, so most teams simply review it, adjust a few phase names or steps to match how they work, and start converting. You only build a framework from the ground up if you want a method that's entirely your own.
4. How a Conversion Actually Runs
Once the blueprint is in place, running a conversion follows a natural flow. You don't have to do these in a rigid order, but this is the shape of the work:
- Set the schedule. Give each phase and sub-phase its planned start and finish dates. These dates give the conversion its timeline and let you compare planned against actual progress.
- Choose what to convert. Build the scope: mark which target data objects (and which of their fields) are in and out of scope for this conversion.
- Connect the sources. For each target object, record which source tables the data comes from.
- Assign the people. Give each object its owners, using the roles from the blueprint.
- Do the work, step by step. As the conversion moves through the phases, each step shows the objects in scope and lets the responsible owner update the status of each one — so progress is always visible.
THE THREAD THAT TIES IT TOGETHER — Everything centres on the list of target objects in scope. The same objects flow through every phase, picking up owners, statuses, and results as they go. That's what makes it possible to answer "how far along are we?" at any moment.
5. Who Does What: Owners
A conversion involves many hands, so OnCoor makes accountability explicit rather than leaving it to a side spreadsheet.
- The blueprint defines the roles (Owner Types) and says, for each step, which roles are Responsible for doing the work and which are Approvers who sign it off.
- The project then puts real people into those roles for each data object.
So the framework answers "what kinds of people are involved and who signs off each step?", and the conversion answers "who exactly owns this particular object?". Together they give a clear line of accountability for every object at every stage.
6. Where to Find Everything
The blueprint is set up in the Implementation Framework Configuration page — reached via Left navigation menu → Pipeline Configuration → Implementation Framework, or Management → Config → Implementation Framework. It's a page of tabs:
| I want to… | Tab |
|---|---|
| Set up or adjust the conversion method | Framework |
| Define the phases and steps | Phase / Sub Phase |
| Define the roles and who approves each step | Owner Type |
Running a conversion happens in the Implementation Framework module (formerly the Conversion module) — reached via Left navigation menu → Process → Implementation Framework, or Management → Conversion. Inside it you move between screens using the left step menu (the phase bar across the top is a status display, not a menu):
| I want to… | In the left step menu, click… |
|---|---|
| Set the schedule | Phase Dates |
| Choose what to convert (and which fields) | Set Scope |
| Narrow which rows come across | Set Scope, then the Relevancy toggle at the top |
| Connect targets to their sources | Object Inventory |
| Assign people to an object | Set Scope, then the people icon on the object |
| Track progress on the work | any work step (Mapping, Cleansing, Build…) |
The step labels come from the blueprint (each sub-phase's Left Navigation Label), so the exact wording and grouping can differ from one setup to the next.
The next two pages cover each half in detail:
- Configuring the Framework — building and adjusting the blueprint.
- Using the Conversion Module — running a conversion day to day.
7. Quick Reference
| Term | In plain words |
|---|---|
| Framework | The whole method a conversion follows |
| Phase | A major stage in that method, done in order |
| Sub Phase | A step within a phase — where the work screens are |
| Owner Type | A role people are assigned to (e.g. Data Owner) |
| Responsible / Approver | Whether a role does the work, or signs it off, for a given step |
| Blueprint (Config) | The reusable definition of the method |
| Project (Conversion) | An actual conversion running against the blueprint |
| Default framework | The blueprint a conversion automatically follows |
| Scope | The list of data objects (and fields) being converted |
Source: OnCoor Implementation Framework product documentation, written for end users. For the latest screens and options, always refer to the in-app interface.