Lost in Your Processes? Get Started with Process Management — article illustration

Start with one process everyone argues about

Process Architecture

Lost in Your Processes? Get Started with Process Management

Lost in your processes? Build one shared picture of how work happens before you try to improve it. Here are the bottom-up and top-down ways to start.

Most teams get started with process management because something went wrong. A customer waited three weeks for an order, an invoice went out twice, and when you ask how that happens, five people draw five different flows on the whiteboard. Nobody is wrong: the process really does look different from where each person stands.

There is a lot of advice about getting started with process management that begins with a tool, a KPI framework or a steering committee. We think that order is backwards. Until the people who do the work and the people who own it agree on how the work happens today, every improvement is a guess about a process that exists only in someone’s head.

This article is about that first step. It covers how to build one shared picture of your processes, whether you start bottom-up from a few pain points or top-down from the company, how to publish it so it stops being a private opinion, and when it is time to move from understanding to improvement.

Why do you feel lost in your processes?

You feel lost because knowledge about how work happens is spread across people, documents and systems that were never reconciled. Nothing is broken in your team; the picture simply lives in too many places, and every place updates at a different speed.

The symptoms are easy to recognize:

  • Every department has its own version of the same process, and the versions disagree.
  • The real process lives in exceptions that only the people doing the work know.
  • A change in one department quietly breaks a handoff in another.
  • Nobody can answer “where does this case wait?” without calling a meeting.
  • Improvement ideas are argued from anecdotes, so the loudest voice wins.

These are symptoms of missing shared knowledge, not of missing software. Buying a modeling tool is a common first response, and on its own it produces a folder of diagrams that everyone suspects and nobody trusts. What is missing is agreement about what those diagrams should say.

We have watched organizations buy a platform first and agree on the process second, and it always runs the same way. The tool fills up with models nobody trusts, the portal quietly empties, and the next project starts from zero. The teams that get somewhere spend their first weeks arguing about how the work really happens. That argument is the work.

Roel Vliegen
Roel Vliegen Co-founder and CEO

What does a common understanding look like?

It looks unglamorous: one place where each process lives, with a model someone owns and the documentation that belongs to it, in a version people are allowed to read. Four things make the difference between a diagram and an agreement:

  • A model of the process as it runs. Not the ideal flow and not the org chart: the steps, decisions, handoffs and exceptions that actually happen.
  • A named owner. One person who can say “this is right”, and who has the authority to keep it right.
  • The documentation that already exists. The procedure, the work instruction, the screenshot, attached to the step it describes instead of living in a folder called Final_v3.
  • A published version. A place every colleague can read without a paid seat, so the model replaces exported PDFs instead of competing with them.

None of this has to be perfect at the start. A model with visible gaps that people trust is worth more than a complete architecture nobody opens.

A process catalog showing processes with their owners and publish state
Figure 1 — One catalog, one owner per process, and a visible difference between drafted and published models.

The platform side of that picture is a process architecture with a catalog, owners and a published Process Portal. The organizational side is harder, and that is what the two routes below are about.

Pick the process your team argues about

Two routes to a shared picture: bottom-up or top-down

You can build the picture from the processes that hurt, or from the company downwards. Both end in the same place: a landscape where every process has a model, an owner and a published version. They differ in where the first month goes and how much coordination they need.

Bottom-up

  • A handful of processes that hurt
  • One architect sets up the workspace
  • A small team edits and reviews
  • A usable result within weeks
  • Scope grows as the team gains confidence

Choose it when the pain is local and a team is willing to own the work.

Top-down

  • The company as a whole, split into value streams
  • Value streams split into processes and subprocesses
  • An architect responsible for each value stream
  • A shared language across the landscape
  • A slower first result, a wider reach

Choose it when everyone needs one language and one landscape.

The honest trade-off is that bottom-up gives you agreement quickly but leaves the landscape uneven, while top-down gives you a landscape but asks more people to learn a method before the first process is useful. Many organizations do both: a top-down frame for the first two levels, then bottom-up work inside each value stream, so the work has a place to land.

How do you get started with process management?

Start small enough that a published first version is reachable, and choose the route by where the pain and the authority are.

If you have a sponsor and a company-wide question such as “which processes do we even have?”, start top-down. If you have a team in pain plus a manager who will release their time, start bottom-up. What you do not need on day one is a complete inventory, a perfect naming convention or a data extract. The first version is built from documents, workshops and the people doing the work; data comes later and makes the picture measurable.

Seats can be mixed per person, so the cost follows the work rather than the headcount. The architect keeps a Process Architecture seat because publishing, governance and the portal live there; the people modeling and correcting a process need a Process Foundation seat; the analysts who add data later need a Process Intelligence seat. The plans and usage limits page spells out what each seat includes.

How does the bottom-up route work?

In the bottom-up route a small team takes a handful of processes and makes them true. The sequence matters less than the ending: the owners correct the models, and everyone agrees on the current state even where it is messy.

  1. Pick the processes you will start with

    Choose two to five processes that hurt, that a team already wants to fix, and whose owner you can name. Resist the “while we are at it” scope: the point is a first agreement, not a catalog.
  2. Put one architect in charge of the workspace

    One person creates the processes, gives each of them a named owner, and prepares the documentation structure. Start with a title, a description and the documents you already have; add sections when a process actually needs them.
  3. Give the team seats that fit the work

    The architect publishes, so they need a Process Architecture seat, and the people editing a process need a Process Foundation seat. Mixed seats keep the first step affordable for a small team.
  4. Load the documentation you already have

    Upload the procedures, work instructions, PDFs and screenshots as artifacts on the process. The old documents are not the goal, but they are the best context for a first draft.
  5. Let AI write the first draft

    Use AI process generation with the uploaded files as context to build a starting model. It will be plausible and incomplete, which is exactly what a first draft is for.
  6. Let the owners correct it

    Each owner goes through the model against their own experience: rename activities, remove steps that do not happen, add the exceptions that do. This is the moment a model becomes knowledge instead of content.
  7. Review it together

    The rest of the team comments on the model and the documentation. Disagreements are the valuable part: they show where the documented process and the real process part ways.
  8. Crowd-source the procedures

    The people who do the work add screenshots and short guides where the text is not enough. Capture the screen, mask what should not be published, and attach it to the step it describes.

For the first weeks this looks messy, and it is supposed to. A model that shows the workaround, the duplicated check and the step everybody skips is more useful than a tidy diagram of a process nobody runs.

When the owner and the team agree the model is honest about today, publish it. Publishing is not the same as finishing: it is the moment colleagues get a version to read instead of the copy in their own folder. Portal viewers exist for exactly that audience, they do not count against paid seats, and about ten come with each Architecture or Intelligence seat, with extra packs of 100 when the whole department wants in.

After that, generate the process documentation from the model instead of maintaining it beside the model. Choose the sections you need in a document template and export Word, PDF or Markdown, so the procedure cannot drift from the process it describes. All documentation you need then comes from one source of truth.

How does the top-down route work?

The top-down route starts with the whole company and splits it until the parts are small enough to own. It produces one language for the landscape, and it asks more of the organization.

  1. Name one owner for the whole project

    This person becomes the architect of the landscape: they hold a Process Architecture seat, monitor progress across value streams, and settle the “who decides?” question that every programme runs into.
  2. Build the architecture with a small team

    Start from the company, split it into five to ten value streams, split each value stream into five to ten processes, and add subprocesses only where a process genuinely needs them. The architecture levels are configurable.
  3. Give every value stream an architect

    Each architect owns their part of the landscape, keeps it consistent with the rest, and reports progress to the project owner.
  4. Assign a process owner to every process

    The value-stream architect does not own the processes inside it. They find the person accountable for the work and make them the owner, because that is where approval will have to come from.
  5. Let each architect run a project team

    The architect gathers the people who model and document their value stream. The architecture setup wizard can generate a draft hierarchy from a description and the documents you already have, so the team corrects a draft instead of facing a blank page.
  6. Steer on progress, not on opinion

    The project owner can see every value stream and the processes in it, spot which ones have no owner or no documentation, and turn the gaps into a list the architects work through rather than an impression.
  7. Iterate until the landscape is complete enough

    Complete means every process has an owner, a model and a version people can read. It does not mean every activity carries a paragraph.
  8. Owners approve, architects publish

    Approval is the owner confirming the model reflects the work. Publication makes it the version every colleague reads, and the point where feedback starts arriving from the people who use the process.

After publication everyone in the organization can read the processes and comment where something is missing. That feedback is how a landscape stays useful between reviews, and it is the cheapest audit an organization will ever run.

Top-down fails when it turns into a documentation project run from the centre. An architecture team can create the frame and the first drafts, and AI makes that part faster than it used to be, but the moment the owners stop correcting those drafts, the landscape becomes fiction with better formatting.

Give every process a name and an owner

What usually goes wrong in the first month?

  • Starting with too much scope. Twenty processes in the first wave means twenty halfway models and no agreement. Five finished processes prove the method.
  • Making a department the owner. “Operations” cannot approve a model. A person can.
  • Documenting the ideal process. The goal of the first pass is an honest current state, including the exceptions. The improvement comes next, and it needs a baseline.
  • Treating publication as the finish line. A published model that nobody reviews is a snapshot. The owner and a review date are what keep it true.

What do you do after the first agreement?

Once owners agree on the current state, improvement becomes a decision instead of an argument. You have a baseline, a named owner and a place to record the change, so the usual improvement questions start having evidence behind them.

Choose improvement ideas together with the owner, scored on the outcome they should change: cycle time, rework, cost per case, or the handoffs that create most of the waiting. Design the new state as a new version of the same model rather than a second document, and compare scenarios in simulation before you commit budget and people to one of them.

Agree a review rhythm as part of the deal: every two to six months for the processes that matter, at least yearly for the rest, with the review on the owner rather than on the architecture team. A review is not a meeting about a diagram. It is the owner confirming that the model still describes the work, and that last quarter’s change actually happened.

When the organization is ready, the last step is data. Upload the event log behind a process and the same model gains evidence: the question changes from “what do we think happens?” to “what does the log say?”. That is what process mining adds, and because it attaches to the model you already agreed on, it is the next step rather than a second programme.

A shared picture is not a luxury that comes after improvement. It is the thing that makes improvement possible. Once it exists, priorities become arguable with evidence, new colleagues get an onboarding path, an auditor gets one record, and the next process you model starts from a catalog instead of a blank page. For the ownership and approval side of that picture, the process governance guide covers how one owner and one published version keep it true, and the RACI guide helps when several people share the work.

If you deliver this for clients, the process architecture partner guide covers the same route from the delivery side, including licensing and the commercial model, and the process intelligence partner guide covers what happens when the client adds data.

Where to Go From Here

You have a process everyone argues about. Model it once, give it a named owner, and publish the version people should read.

Frequently Asked Questions

Start with one shared picture of how work happens, not with a tool. Pick a scope you can finish, name an owner for each process, collect the documents you already have, agree on a current state that people recognize, and publish it before you improve anything.

Bottom-up starts with a few processes and a small team that owns them, so you see a usable result quickly. Top-down starts with the company as a whole: value streams first, then processes and subprocesses, with an architect responsible for each value stream. Many organizations combine a top-down frame with bottom-up work inside it.

One named person who knows the work and has the authority to make a change stick. The owner does not have to draw the model: their job is to decide what it should say, correct the draft, and approve the version everyone reads.

No. Document the processes in scope at the level you need to make a decision, and expand when a process is actually used, discussed or audited. A small catalog with trusted models beats a complete inventory nobody reads.

A bottom-up scope of a handful of processes can produce a published first picture in weeks. A company-wide landscape takes longer, because it depends on how many value streams you define and how quickly owners can review their part.

No. The first step is agreement about the process, which you build from documents, workshops and the people doing the work. Adding event data later turns the same model into measured insight, instead of starting a second programme.

Related Blog Posts

Receive expert insights on process mining and workflow optimization in your inbox
AI and Business Process Architecture: One Curated Truth

Process Architecture

AI and Business Process Architecture: One Curated Truth

AI helps draft and analyze your architecture. People still decide what is true: one curated source, governed versions, Enterprise assistants via MCP.

Choosing an ARIS Alternative

Process Architecture

Choosing an ARIS Alternative

ARIS is the deeper repository; ProcessMind is the smaller product with the features that decide the work. Compare them in one matrix.

Enterprise Architecture Tools: How to Choose the Right Fit

Process Architecture

Enterprise Architecture Tools: How to Choose the Right Fit

Compare enterprise architecture tools by the job each one does, and see where process data keeps the architecture honest.

Process Architecture Consulting: What a Partner Can Deliver

Process Architecture

Process Architecture Consulting: What a Partner Can Deliver

A partner's guide to process architecture consulting: the roles you can take, how a client landscape gets built, and how licensing and margin work.

Design better processes. Build a connected architecture. Stay in control.

Get instant access with no credit card and no waiting. Turn the way your organization works into clear, connected process designs.

Build your process architecture, define ownership and controls, and align roles and responsibilities across every level.

Start your free trial and create one reliable foundation for governing, managing, and continuously improving your processes.