Publicité
ERP IMPLEMENTATION
🇫🇷 Lire en français →

As-Is and To-Be Process Mapping Before an ERP Project: A 4-Week Workshop Method

ERP process mapping: levels of detail, a 4-week plan, as-is workshops, to-be design, a process sheet template and the handover to fit-gap and testing.

As-Is and To-Be Process Mapping Before an ERP Project: A 4-Week Workshop Method

An ERP project that starts without process mapping is like moving house without an inventory: you find out along the way what exists, what is missing and what nobody really wanted to take with them. Gaps surface at fit-gap, the most expensive moment to deal with them, or worse, during user acceptance testing, when someone notices that “the Friday customer dunning run” was never planned for.

As-is (current state) and to-be (target state) mapping is the deliverable that prevents this scenario. But it has a bad reputation: too long, too theoretical, and ultimately filed in a shared folder nobody opens. This guide proposes a 4-week method, bounded in scope and aimed at a single goal: feeding the fit-gap and the test plan with processes described in a usable way.

Why Map Before You Select or Configure

A process described in a requirements document is almost never the process actually practiced. The first is an intention; the second is the result of years of adjustments, side spreadsheets and unwritten rules. Mapping means writing down the second, then deciding which of the two you want in the new system.

Three drifts come back systematically when this step is skipped.

Implicit processes are forgotten. These are the ones nobody mentions in meetings because they “go without saying”: the sales director’s informal approval of a discount, the accounting team’s manual check of a supplier IBAN, the visual inspection of a batch before shipping. They appear in no requirements document and reappear as defects after go-live.

Scope drifts during the project. Without a common baseline, every workshop rediscovers special cases, and every special case argues for a custom development. Functional scope control then becomes a permanent negotiation instead of a decision made once.

Defects are reproduced as-is. Without a critical look at the current state, the new ERP is configured to imitate the old one, workarounds included. You pay for a migration to get your old pain points back.

Mapping does not solve these three issues on its own, but it makes them visible at a moment when fixing them costs only a conversation.

Scope and Levels of Detail: Knowing When to Stop

The main cause of failure in a mapping exercise is the lack of a stopping rule. You can describe a company indefinitely. So before the first workshop, set three levels and the target level for each domain.

LevelContentExample (procurement)Use in the project
L1: value chainMajor macro-processes and their linksBuy, produce, sell, invoice, closeScoping, choice of priority domains
L2: processSequence of steps, actors, documents, systemsFrom purchase requirement to supplier paymentBasis for fit-gap and to-be design
L3: proceduresDetailed operating mode, screens, calculation rulesEntering an invoice with a price varianceTraining, detailed tests, only when needed

The practical rule: L2 is the working level, L3 is the exception. Go down to L3 only in three cases: the process is critical (accounting, regulatory or contractual impact), it contains calculation rules the ERP will have to reproduce, or it is performed by very few people and is therefore fragile.

For secondary domains, stop at L1 and simply note that they will be handled later. A solid L2 map of the five processes that concentrate the value beats a superficial inventory of forty processes.

Also set explicit boundaries: which legal entities, which sites, which activities. A subsidiary forgotten at this stage ends up in wave 2 of the project, with the multi-site governance decisions to be made all over again.

The 4-Week Work Plan

Four weeks are enough for an SME or mid-market company on a scope of five to eight L2 processes, provided calendars are blocked. The rhythm below assumes a facilitator (project manager or consultant), one process owner per process and a sponsor who validates trade-offs.

Week 1: Scoping and Collection

  • Objective: set the L1 scope, name the process owners, collect existing material.
  • Activities: 2-hour kick-off workshop, inventory of documents (written procedures, org charts, forms, exports from the legacy system), scheduling of interviews.
  • Deliverables: L1 map, list of selected L2 processes with their target level, workshop schedule, validated process sheet template.
  • Roles: sponsor (validates scope), facilitator (prepares), process owners (make themselves available).

Week 2: As-Is Workshops

  • Objective: describe the process as it is actually practiced.
  • Activities: one 2 to 3-hour workshop per L2 process, with the users who perform it, not only their manager. Additional one-to-one interviews for special cases.
  • Deliverables: draft as-is diagram and process sheet for each domain, list of exceptions, list of pain points.
  • Roles: key users (describe), facilitator (formalizes live), a second participant (takes notes to free up the facilitator).

Week 3: Triage and To-Be Design

  • Objective: decide what to keep, simplify or remove, then draw the target.
  • Activities: as-is review with process owners, exception triage, to-be workshops per process, trade-offs with the sponsor.
  • Deliverables: to-be diagram, design decision log, list of points to address at fit-gap.
  • Roles: process owners (propose), sponsor (arbitrates), IT (checks consistency of flows and interfaces).

Week 4: Consolidation and Handover

  • Objective: lock the deliverables and hand them over.
  • Activities: cross-review between processes (the inputs of one process are the outputs of another), formal validation by each process owner, preparation of the handover.
  • Deliverables: final package (L1 map, L2 as-is and to-be sheets, decision log), list of anticipated gaps, first test scenarios.
  • Roles: process owners (sign off), project manager (assembles), fit-gap team (receives).

If your scope exceeds eight processes, do not extend the duration: split it into two waves, the second starting after the first fit-gap.

Running an As-Is Workshop

A good as-is workshop lasts two to three hours, brings together four to six people who actually perform the process, and takes place in front of a medium everyone can see (wall, whiteboard or collaborative tool). The facilitator draws as the discussion goes: immediate validation by participants avoids the deferred review where you discover that nothing matches.

Question Framework

Start from the trigger and follow the flow, asking the same questions at every step.

  • Trigger: what starts this process? An event, a document, a deadline?
  • Actors: who does what, in which department, with what level of authorization?
  • Inputs and outputs: which documents or data come in, which go out, to whom?
  • Tools: which software, which spreadsheet, which paper form? Where is data re-keyed?
  • Rules: what drives a choice (approval threshold, deadline, priority)? Where is the rule written down?
  • Exceptions: what happens when things do not go as planned? How often?
  • Controls: who checks, how, and what happens to an anomaly?
  • Pain points: where do you lose time, where do errors recur?

One particularly productive question: “Show me the last time it went wrong.” It brings out real cases instead of generalities.

Pitfall: The Idealized Process

The main risk of a workshop is describing the official process. Three mechanisms cause it: the presence of the line manager, which prompts people to answer “the way it should be done”; the fear that admitting a workaround will be seen as a fault; and the natural tendency to describe the average case while forgetting the painful ones.

A few concrete countermeasures:

  • Separate the manager from the people doing the work for the description phase, then bring them together for validation.
  • Set an explicit frame: we are documenting to design a better tool, not to evaluate people.
  • Ask for evidence: an example of a real document, a screenshot, an Excel file used daily. A parallel spreadsheet is almost always the sign of a need the current tool does not cover.
  • Complement with observation: thirty minutes next to a user teaches more than two hours of discussion.

This phase can be supported by data: if you have traces in your systems, a process mining approach lets you compare what people say with what the flows actually show. It does not replace the workshop (it does not tell you why people work around the system), but it shows where to dig.

Triaging Exceptions: Useful Rules or Historical Workarounds

Every as-is workshop produces a list of exceptions. The temptation is either to carry them all into the to-be, or to sweep them away wholesale. They need to be triaged, with explicit criteria.

CriterionQuestion to askIf yes
External obligationDoes the rule stem from a law, a standard, a customer contract or an audit requirement?Keep the exception, trace it to its source
Business valueDoes the rule protect a margin, a strategic customer, quality or safety?Keep the exception, quantify it if possible
FrequencyDoes the case occur regularly or once a year?Rare cases can stay manual
OriginDoes it exist because the old tool could not do it?Historical workaround: candidate for removal
OwnerCan someone explain why the rule exists?With no answer, challenge it

A historical workaround is not bad practice in itself: it solved a real problem in a given context. The question is whether that problem still exists in the target tool. The answer is often no, because the ERP’s standard functionality already covers the need in a different way.

For each exception you keep, record three things: its justification, its owner, and the envisaged solution (configuration, workflow, development). That last point foreshadows the fit-gap.

Moving to To-Be: Design Principles

The to-be is not an as-is “but better”. It is a design exercise carried out with explicit principles; otherwise every participant optimizes their own area.

Standardize before you customize. Start from the standard operation of the chosen (or shortlisted) ERP and depart from it only for a documented reason. If the vendor is not yet selected, design the to-be in terms of capabilities rather than screens, so that you can test it against several offers.

Simplify before you automate. Automating a complicated process freezes its complexity. First remove the steps with no value: redundant approvals, re-keying, documents nobody uses.

One data point, one entry, one owner. Each piece of information should be created once, at the source, by the person who knows it. This principle drives most of the gains from an ERP, and it is the one legacy systems violate most often.

Design controls, not just flows. Each approval step in the to-be must answer an identified risk. A control with no associated risk is dead weight; a risk with no control is a hole.

Think about interfaces. A to-be process often crosses systems that are not in the ERP (CRM, payroll, WMS, invoicing platforms). Mark them explicitly so that IT can assess the integration effort.

Design Decisions to Trace

Each significant choice gets a line in a decision log, with the date, the options considered, the decision, its author and its rationale. The log serves at two moments: when someone challenges a decision mid-project (“why did we remove this approval?”), and when a newcomer takes over the file. Without it, the same trade-offs are rediscussed at every steering committee.

Notation and Tools

Simplified BPMN or Flowchart

BPMN 2.0, standardized by the Object Management Group, is the reference notation for process modeling. Its vocabulary is rich: events, gateways, sub-processes, pools and lanes. That richness is an asset for a modeler and a handicap in a workshop with business users.

The pragmatic recommendation: use a BPMN subset and stick to it.

  • Lanes (one per actor or department) to show who does what.
  • Tasks for actions, start and end events for boundaries.
  • Exclusive gateways (one path among several) for decisions.
  • Annotations for rules and exceptions, rather than advanced constructs participants will not read.

A simple flowchart is enough for linear processes and for teams unfamiliar with the notation. What matters is consistency: one convention across the whole project, explained on one page, and a shared tool (a collaborative diagramming tool is enough; there is no need to buy a modeling suite for a scope of eight processes).

Process Sheet Template

The diagram is not enough: it shows the sequence, not the rules. Each L2 process must come with a sheet in an identical format, to copy into your project folder.

SectionExpected content
Name and IDShort title, code (e.g. PUR-02)
Process ownerName and role of the responsible person
ObjectiveExpected outcome, in one sentence
TriggerEvent that starts the process
Actors and rolesWho is involved, with what rights
Inputs / outputsDocuments and data, source and destination
Systems usedCurrent tools, parallel spreadsheets included
Steps (as-is)Link to the diagram and summary of steps
Business rulesThresholds, deadlines, calculations, conditions
ExceptionsSpecial cases, frequency, current handling
ControlsValidations and checks, who is responsible
Volumes and frequencyOrder of magnitude, seasonal peaks (internal data)
Pain pointsIssues observed, as phrased by users
Target (to-be)Decided changes, reference to the decision log
ImpactsOrganization, training, interfaces, reporting
Anticipated test casesNominal and exception scenarios to test

The last section is the most useful and the most often forgotten: it links to the acceptance testing phase (see below).

Handover to Fit-Gap and the Test Plan

Mapping has value only if it is consumed. Two handovers must be prepared from week 4.

To fit-gap. Each to-be step is checked against the solution’s standard: covered, configurable, to be adapted, to be developed. This is the purpose of fit-to-standard workshops and of the facilitation method described in our guide to fit-gap and standard/custom gaps (in French). Good mapping saves an entire workshop: participants arrive with the rules written down, the exceptions triaged and the design decisions already made. Fit-gap then focuses on the question that belongs to it: can the standard do it?

To the requirements document. Process sheets feed functional requirements directly. If you are writing a document to consult vendors, see our guide on writing an ERP requirements document: the business rules and retained exceptions become requirements, and the pain points become evaluation criteria.

To the test plan. Each to-be process becomes an end-to-end scenario: one nominal case, plus one case per retained exception. The anticipated scenarios recorded in the sheet form the basis of the acceptance cases. The users who described the process in the workshop are best placed to validate these cases, which reduces acceptance-testing arguments about “what was planned”. For what comes next, our UAT checklist before go-live details how to organize that phase.

The Role of the Process Owner

Each L2 process has a named owner, on the business side rather than the IT side. Their role goes beyond mapping:

  • they validate the as-is sheet (“yes, that is how we work”);
  • they arbitrate the exceptions in their area with the sponsor;
  • they take part in fit-gap and defend the need against standard-based proposals;
  • they validate the test cases and sign off acceptance for their process;
  • they carry the change to their team at deployment.

Appointing a process owner who has neither the authority nor the time for the role is a frequent mistake. Plan their workload in the schedule from the start (for example half a day per week during the mapping) and get it recognized by their management.

Common Mistakes

  • Mapping the whole company. Without a stopping rule, the project bogs down. Set L2 as the working level and limit the scope to the processes the ERP will actually touch.
  • Having the manager alone describe the process. They know the rule, not the practice. Bring in the people who do the work.
  • Producing diagrams without sheets. A diagram without business rules supports neither fit-gap nor testing.
  • Mixing as-is and to-be in the same workshop. Participants start defending solutions before they have described the problem. Separate the two.
  • Never cross-reviewing between processes. Breaks happen at the interfaces: the output of the ordering process is not always the input of the invoicing process. Plan a cross-review.
  • Delivering without formal validation. A sheet not signed by its process owner will be challenged at fit-gap. The signature is a scoping act, not a formality.
  • Shelving the file after week 4. The map must stay alive until acceptance: every design decision changes the sheet.

Going Further

To structure the rest of the project, read our guide to fit-to-standard workshops and 6-week scoping and our article on writing the ERP requirements document. And to compare your future solution on objective criteria, download our ERP checklist and evaluation grid: 30 criteria to benchmark several vendors side by side, based on the processes you have just mapped.