This article is written for business owners and executives who still do not fully understand what process management is: how to document processes, what to manage, why AS-IS and TO-BE models are needed, which metrics to track, which tools to use at the start, and which to move to later. At the end, you’ll find practical templates and a brief PMBOK overview for managing implementation as a full-scale project.
- What Is a Process? A Simple Explanation
A process is a set of repeatable actions that transform what we receive as input (raw materials, information, customer requests) into what we need as output (services, products, decisions), with a known level of quality, within a defined timeframe, and at a clear cost.
Any process consists of several elements:
Inputs — what comes in at the start: a customer request, a brief, source data, files, a contract.
Steps — who does what exactly, what actions they perform, and which systems they use.
Outputs — what should be produced in the end: a finished product, a report, an email to the customer with a decision.
Roles and responsibilities — who is accountable for the final result. It’s important that this is one specific person, not a vague “everyone together.”
Rules and quality criteria — how to tell whether the result truly meets expectations.
Performance metrics — how we measure speed, cost, quality, and potential risks.
Why manage processes at all? To reduce chaos in day-to-day work, make timelines predictable, control unit cost, and clearly identify where automation or artificial intelligence can be implemented with real value.
- Basic principle: first document AS-IS, then design TO-BE
AS-IS (current state) is an honest description of how the process works in real life. Who does what, where files get lost, where time goes, and where bottlenecks and queues form.
TO-BE (future state) is the target process model: simpler, faster, cheaper, without unnecessary steps, with automation and AI implemented where they deliver measurable value.
Why not start by drawing the ideal process right away?
There is a high risk that you will invent something detached from reality and fail to account for actual constraints and dependencies.
The team may not accept the changes, because they will say, “That doesn’t work here; you don’t understand our specifics.”
You may get the priorities wrong: automate something unnecessary, while the real bottleneck remains.
The right sequence looks like this: quickly document the current AS-IS state in one to two weeks, identify the 20% of steps that create 80% of the problems, outline quick wins and the TO-BE state, launch a pilot project, and then scale it across the company.
- Where to Start: The Simplest Tools for the Beginning
Minimum tool set for the initial stage:
Miro, Mural, or FigJam — to sketch a process map as a flowchart. It’s visual and easy for everyone involved to understand.
Google Sheets or Excel — to create a list of steps, roles, service-level agreements (SLA), metrics, and risks.
Google Forms or Notion — to quickly create information-gathering forms and checklists as temporary “automation.”
Standard Operating Procedures (SOPs) — short one- to two-page instructions on how the work is done. They’re needed to train new employees.
When does it make sense to move to more advanced tools like BPMN and process mining?
BPMN (Business Process Model and Notation) is needed when a process has many branches, approvals, and integrations, and you need to describe the logic unambiguously. BPMN is also useful when different teams work on the same process and need a common language.
Process mining is needed when you have event logs from your systems (CRM, ERP, ticketing systems) and want to see the real flow of work, understand where deviations from the standard occur, and where delays arise.
- How to Document an AS-IS Process Quickly in One to Two Work Weeks
Step 1. Define the process boundaries with SIPOC
SIPOC is a simple five-element template:
Suppliers — who provides the inputs: customers, the sales team, contractors.
Inputs — documents, data, materials that enter the process.
Process — five to twelve key steps described at a high level.
Outputs — what results are produced: a completed delivery, a report, an activated service.
Customers — who needs it: an external customer or an internal department.
Important rule: if twelve steps don’t fit on your map, you’re drawing too much detail. Make the description broader. The details can be moved to the standard procedure level.
Step 2. Walk through the process yourself
Conduct three to five short interviews lasting 30–45 minutes with the people involved in the process.
Ask simple questions: what do you do, how do you measure success, what gets in the way, where is time lost?
Collect examples of real artifacts: forms, emails, templates, scripts.
Step 3. Document roles and responsibilities using a RACI matrix
RACI is a way to assign responsibility:
R (Responsible) — the person who does the work.
A (Accountable) — the person responsible for the final result. This is always one person.
C (Consulted) — experts who are consulted during the process.
I (Informed) — those who are kept up to date.
Create a simple RACI table for the process steps. Each step should have exactly one person marked with A.
Step 4. Capture current metrics
Speed: Lead time (the time from receiving the request to delivering the result), Cycle time (the time of active work on the task).
Quality: rework rate, First Pass Yield (the share of work done correctly the first time), number of defects per 100 cases.
Cost: labor hours multiplied by the rate, plus tool costs, plus losses from defects and rework.
Reliability and risks: where problems occur most often, and at which stages delays form.
Step 5. Identify bottlenecks — the three to five biggest problems
Signs of bottlenecks:
Queues build up, and approvals take a long time.
Lots of manual copy-pasting of data between systems.
Many exceptions and manual handling of nonstandard cases.
One person becomes the “bottleneck,” and everything passes through them.
- How to Design TO-BE: Principles and Sequence of Actions
Core design principles:
First remove everything unnecessary, then automate. This is a Lean principle.
Standardize processes: create SOPs, checklists, and templates.
Automate the simple things first (forms, no-code integrations), then move on to the complex ones (BPM systems, robotics, AI agents).
Build measurement into the process: metrics should be calculated automatically, without manual work.
Make the process visible: task status boards, SLA tracking, automatic notifications.
Assign a Process Owner with real decision-making authority.
Sequence of actions:
Get quick wins in two to four weeks: eliminate duplication, create forms, set up notifications.
Design the standard: define inputs, steps, outputs, definition of done criteria, and assign roles using RACI.
Identify AI use cases: where there are texts and repetitive decisions, you can apply classification, information extraction, automatic summarization, autofill, and suggestions.
Calculate the economics: estimate return on investment using the formula ROI = (benefit minus costs) divided by costs. Start with one or two high-volume or high-cost processes.
- Where and how to use AI in processes — without the hype
Typical use cases:
Handling incoming requests (email, forms): automatic parsing, categorization, extraction of details, autofill in CRM or ERP.
Document work: draft generation, checklist-based approvals, version comparison, and finding deviations from standards.
IT support and Service Desk: answers based on the knowledge base, troubleshooting recommendations, and step-by-step instructions for the operator.
Sales and marketing: automatic call summaries, extraction of next steps from conversations, customer segmentation, and email personalization.
Quality control: compliance checks against standards (SOP), risk identification, and anomaly detection.
Process analytics: identifying recurring causes of delays based on log analysis.
Safety rules for implementing AI:
Clearly define data boundaries: which fields can be sent to the model and which cannot.
Human-in-the-loop: critical decisions must be made with human confirmation.
Keep logs: who did what and when — everything must be traceable.
Set quality criteria: accuracy, completeness, the model confidence threshold, and an action plan if quality drops.
- BPMN basics — without overwhelming the reader
Use BPMN in the following cases:
When the process has many branches and decision points (exclusive and parallel gateways).
When there are tasks performed by both people and automated systems.
When events matter: timers, exceptions, and messages between systems.
It is enough to know the basic elements:
Task and sub-process
Start and end events (Start Event, End Event)
Exclusive and parallel branches (XOR and AND gateways)
Pools and lanes for different roles
Messages and timers
This set is enough for everyone to understand the process the same way and stop arguing over meanings.
- What process mining is and when you really need it
Process mining is the analysis of real event traces from your IT systems. For the analysis, you need three minimum fields: Case ID, Activity, and Timestamp, plus user information if possible. You see not how the process was designed, but how it actually happens: all path variations, delays, bottlenecks, and SLA breaches.
What you need for process mining:
Raw event logs from systems with at least three fields: Case ID, Activity, Timestamp.
An agreed-upon step dictionary: how system statuses map to activities in the process.
Privacy safeguards: anonymization of personal data and access control settings.
When process mining pays off:
Large volumes of similar cases — thousands per month.
You are dealing with SLA breaches and do not understand exactly where the failure occurs.
You need to objectively verify the impact of implemented changes by comparing before and after.
- Metrics: cost, quality, risk, timelines
Cost:
Cost per case: hours worked multiplied by the rate, plus licenses per 1,000 cases and losses from defects, divided by the number of cases.
Automation ROI: time savings multiplied by the rate and by volume, minus license and implementation costs, divided by costs.
Total cost of ownership (TCO): the cost of owning the tool over 12–24 months, including licenses, integrations, and support.
Quality:
FPY (First Pass Yield) — the share of cases completed correctly the first time, without rework.
NPS or CSAT — customer satisfaction.
Defect rate — the number of defects per 100 cases, broken down by error type.
Risks:
Operational risks: dependence on a single expert, manual workarounds, shadow files and databases.
Compliance risks: missed regulatory deadlines, incomplete records for audit.
Technical risks: integration issues, AI solution reliability, and model quality drift over time.
Timelines:
Lead time — total time from request receipt to delivery of the result.
Cycle time for each step — active work time.
On-time completion rate (On-time percentage by SLA).
- Change management: how to avoid breaking the business along the way
Appoint a process owner who is accountable for results and metrics, not the group as a whole by committee.
Communicate regularly and briefly: what is changing, why, and when.
Train people: one-page SOP instructions plus short 10-minute how-to videos.
Run a two- to four-week pilot on a limited sample with target metrics.
Collect feedback through a form: 'What is slowing things down? What can be improved?'
Work in increments: do not implement everything at once; every two to four weeks should deliver visible value.
- How to run implementation the right way — a plain-English PMBOK summary
In the PMBOK methodology, implementation is viewed as a project with stages and management areas. We will cover only the essential minimum, without unnecessary academic language.
Project life cycle:
Initiation: why we are doing this (business goal), who the project sponsor is, and what constraints exist.
Planning: what is and is not included in the project (Scope), timelines, budget, risks, and communication plan.
Execution: we do the planned work, manage the team and vendors.
Monitoring and control: compare plan versus actual, manage changes.
Closing: summarize results, document lessons learned, and hand the process over to operations.
Key management areas (simplified version):
Scope: list of processes and their boundaries. Use WBS (work breakdown structure).
Schedule: roadmap with stages — assessment, AS-IS, TO-BE, pilot, scaling.
Cost: implementation budget, licenses, training. Transparent ROI calculation.
Quality: definition of done or not done, test cases, target process metrics.
Resources: roles — process owner, analyst, architect, developer, subject matter expert.
Communications: who gets what and when, weekly status updates.
Risk: risk register, response plan — avoid, reduce, accept, or transfer.
Procurement: selecting platforms through a tender or comparison, service level agreements with contractors.
Stakeholders: stakeholder map, their expectations, and their influence on the project.
Change Control:
Any significant change must go through a change request: what is changing, why, and how it affects time, cost, and quality. The decision is made by the sponsor or the change control committee.
Progress Measurement:
Weekly: plan vs. actual comparison, short one- to two-page reports.
Results demos every two to three weeks (showcase).
Pilot exit criteria: metrics improved by the target amount, risks accepted, users trained.
- Step-by-Step Implementation Plan — Consulting Template
Kickoff (one week):
Define goals, project scope, list of candidate processes, success metrics, and team composition.
AS-IS Assessment (one to two weeks):
Create a SIPOC, draw a map in MIRO with 10-12 steps, build a RACI matrix, collect metrics, and identify the top 5 bottlenecks.
Quick Wins (two to four weeks):
Create forms and checklists, set up automated emails and notifications, and remove duplicate work and manual data entry.
TO-BE Design (two to three weeks):
Develop the process standard (SOP), draw the target map (if needed, in BPMN notation), define AI application points, and plan integrations.
Pilot (four to eight weeks):
Launch in one department or segment, track metrics, and survey users.
Scale-Up (eight to twelve weeks):
Roll out to the remaining teams, provide training, and establish support procedures.
Operating Model:
Assign a process owner, conduct a monthly metric review, maintain an improvement backlog, and implement quarterly increments.
- Mini Guide to Artifacts — Copy These as Templates
13.1. One-Page AS-IS Checklist:
Purpose of the process and who the “customer” is.
Inputs and outputs (SIPOC model).
Eight to twelve steps on the map.
Roles (RACI matrix), process owner (full name, authority).
Current metrics: lead time, cycle time, FPY, cost per case.
Top 5 issues and their business impact.
13.2. Metrics Dashboard in Table Format:
Metric | Definition | Data Source | Target Value | Alert Threshold | Measurement Frequency | Owner
13.3. Step Execution Standard (SOP):
Step objective, what comes in, what should come out, readiness criteria, which tool is used, who performs it, checklist of what to verify, common mistakes.
13.4. Communication Plan:
Audience | Message | Format | Frequency | Owner
13.5. Risk Register:
Risk | Probability | Impact | Risk Owner | Response Plan | Monitoring Triggers
13.6. Change Request:
What is changing, why, the “before and after” scenario, impact on schedule, cost, and quality, decision date.
- Examples of Common Improvements by Industry
B2B sales: a single lead form, automated qualification, SLA for response time, automatic opportunity creation in CRM, email templates, AI-powered call summarization.
Customer support: ticket classification, a knowledge base with suggested solutions, escalation timers, control of repeat inquiries.
HR recruiting: standardized job brief, automatic resume parsing, screening questions, interview slots, a unified candidate evaluation system.
Finance: AI-powered invoice reading, verification of details, routing for payment, audit trail.
Procurement: request intake, three-way matching (purchase order-delivery-invoice), variance control, reporting.
- How to Measure the Impact — Quick ROI Calculator
Time savings: (minutes per case before implementation minus after) multiplied by the case volume and hourly rate.
Reduction in defects and rework: (defects before minus defects after) multiplied by the cost of one defect.
Revenue growth (if applicable): increase in conversion rate multiplied by average order value and volume.
Costs: licenses, integrations, training, support.
12-month return on investment = (Benefit minus Costs) / Costs.
Payback period = Costs / Monthly benefit.
- Common Mistakes and How to Avoid Them
Designing the ideal process right away without AS-IS analysis — you will miss real constraints and dependencies.
Automating a bad process — first remove the unnecessary steps, then automate.
No process owner — nobody tracks the metrics, and the process drifts back into chaos.
A BPMN notation that is too complex — the team does not read the diagrams, and the value is lost.
Implementing AI without rules — data confusion, unpredictable quality, and business risk.
No pilot — you scale a rough solution and lose the team’s trust.
Not measuring impact — the debate becomes “do we like it or not” instead of “is it profitable or not.”
- Glossary at a Glance
AS-IS / TO-BE — the current and target process model.
SIPOC — suppliers, inputs, process, outputs, customers.
RACI — responsibility assignment matrix.
SOP — standard operating procedure.
Lead time / Cycle time — total completion time / active work time.
FPY — first pass yield, the share of cases completed without rework.
BPMN — Business Process Model and Notation.
Process mining — analysis of actual process logs.
Owner (process owner) — the person responsible for results and metrics.
- 30-Day Quick Start — Summary
Week 1: kickoff, SIPOC, AS-IS map, metric baseline, identification of the top 5 issues.
Week 2: develop standards (SOPs), create checklists and forms, eliminate duplication, and implement the first automated actions.
Week 3: TO-BE design, role model, identify AI application points (one or two patterns), and plan the pilot.
Week 4: launch the pilot, train the team, monitor metrics, prepare a before-and-after view, and decide on scaling.
- What to Add from PMBOK as Mandatory
Sponsor and clear goals: formally assigned, with measurable business outcomes.
Work breakdown structure (WBS) and roadmap: clear task decomposition and milestones.
Risk management: risk register plus response plan, reviewed every week.
Communication plan: schedule for status updates and results demos.
Change management discipline (Change control).
Lessons learned: a retrospective at the end of the pilot and after scaling.
- Ready-made mini templates — copy them for yourself
SIPOC (one table):
Suppliers | Inputs | Process (8–12 steps) | Outputs | Customers
RACI (table excerpt):
Step | R | A | C | I
Metric card:
Name | Formula | Data source | Target value | Alert threshold | Owner | Measurement frequency
SOP template for a step:
Purpose | Input | Output | Definition of done | Tool | Role | Action checklist | Common mistakes
Change Request:
Change description | Rationale | Impact (Scope/Time/Cost/Quality) | Risks | Decision | Date
Summary
First, document the AS-IS state using simple tools like MIRO and basic spreadsheets. Capture the metrics and identify the main problems.
Second, design the TO-BE state. Remove anything unnecessary, standardize what remains, add basic automation, and introduce one or two AI use cases with clear, measurable metrics.
Third, launch a pilot project. Measure the impact, train the team, and assign a process owner with clear authority.
Fourth, scale the solution and put operational process management in place. Review metrics regularly, maintain an improvement backlog, and hold monthly reviews.
Fifth, manage the entire implementation as a full project under PMBOK principles. Set goals, build a plan, manage risks, establish communications, and implement change control discipline.
The main thing is not to try to make everything perfect right away. Work in iterations, get quick wins, learn as you go, and gradually build process management maturity across the company. Start small, but start right.