← Back to blog

Capture Process Context: What to Record Beyond the Steps

November 15, 2026
Capture Process Context: What to Record Beyond the Steps

To capture process context, you record everything that explains why a process runs the way it does: the conditions that send work down one path instead of another, the exceptions, the handoffs, the people involved and the reasons behind each step. A list of steps tells a new hire what to click. Context tells them what to do when the case in front of them does not look like the example. The most reliable way to get it is to ask the person who does the work, in their own words, and keep asking "why" until the judgment behind each step is on the page. That is the interview approach we built Kept around.

Kept
Keep Process Context From Being Lost
Kept uses guided conversation to turn employees’ process knowledge into structured workflows, preserving the decisions and exceptions behind each step.
Visit

TL;DR

  • Process context is the data, roles, conditions and reasons that make a generic process fit one real case. Steps alone do not hold it.
  • Capture dependencies, stakeholders, restrictions, data, external services and, above all, decisions and exceptions.
  • Draw it out by following one real case from trigger to finish, asking why at every fork and listing every exception.
  • Give every document an owner and a review rhythm, and treat each new-hire question as a sign of a gap.
  • Guided conversation turns what people say into structured workflows, so context is recorded while the person still remembers it.

Table of Contents

What process context actually means

The phrase shows up in two very different worlds. Search for it and you will mostly find operating-system material about CPU registers and context switching. That is not what we mean here. In business workflows, process context is the information that surrounds and shapes a process as it runs.

SAP's learning material defines it as the sum of all data, including role information, carried and changed as the process moves through its events and activities. That data also decides direction: a condition at a gateway looks at values in the process data to choose which path the work takes.

A useful way to put it: the process definition describes the general who, what, when and why. The context explains what those elements mean for this particular case. An order, for example, supplies the concrete facts, and handling it can add more, such as a translated requirement or a storage reference. The same reference notes that shared data definitions keep different people and systems from reading the same information differently.

In plain terms, a process document is a map. Context is the knowledge of the terrain: which road floods, which bridge the client refuses to cross, which shortcut is fine on Tuesdays but not at month end.

Why steps alone fail you

Most documented procedures capture the happy path. They are tidy, numbered and quietly useless the first time something unusual arrives. We see the gap in two columns:

What the document holdsWhat the person holds
The order of stepsWhy that order, and when it changes
Roles and ownersWho actually gets the call when the owner is out
The standard thresholdThe cases where the threshold is waived or doubled
Required fieldsWhich fields people never trust, and the check they run instead
The approved toolThe workaround everyone uses when the tool lags

When the person leaves, the right-hand column leaves with them. Researchers behind the ACKNOWLEDGE knowledge-capture tool describe the aim as turning employees' case experience and decisions into reusable knowledge linked to process activities. The benefits they expected were avoiding knowledge loss when members leave, better execution and faster training of new members. Their core argument is that organizational knowledge only exists once individual experience is put into words, evaluated, packaged and attached to the activity it belongs to.

We make the same point in more detail in Documentation captures what people do. It misses how they decide.

What to capture alongside every step

A preservation project known as TIMBUS looked at what it takes to keep a business process usable years later. Its conclusion was that you must document both the process structure and its context, because the context holds the dependencies and conditions needed to run the process again with its original behavior. The elements it lists are a good checklist for any team:

  • Dependencies: what must be true or finished before a step can start.
  • Stakeholders: who is involved, who is affected, who signs off.
  • Restrictions and requirements: legal, contractual, policy or customer-specific rules.
  • Data: what goes in, what comes out, and where it lives.
  • External services: the vendors, systems and partners the process leans on.
  • Business, application and technology aspects: the human, software and infrastructure layers.

The same paper adds that metadata and execution logs help with understandability and provenance, meaning you can tell where a piece of information came from and when.

For the people side, we would add three items the structure checklist tends to miss:

  1. Decision rules and their reasons. Not "approve if under the limit" but "approve under the limit unless the client is on a payment plan, because finance reverses those."
  2. Exceptions. What happens when the rule is broken, who decides, and what comes next.
  3. Handoffs. At each one: what the next person receives, what they expect to receive, and what they do when it is incomplete.

Keep these three layers linked rather than stuffed into one giant file: a process overview, a work instruction for each step, and a record of the judgment calls. The point is that a reader can move from overview to execution to judgment without losing the thread.

How to capture process context, step by step

This routine works for a single process owned by one person or a complex workflow spanning departments. Start small: one process, one practitioner.

1. Pick a process that hurts to lose

Choose work that depends on one or two people, where a mistake is costly or a new hire takes months to become competent. Month-end close, vendor onboarding, escalations and customer exceptions are common candidates. Do not begin with the process that is easiest to document. Begin with the one whose loss you would feel first.

2. Follow one real case from trigger to completion

An abstract description ("I usually do X, then Y") flattens everything interesting. Instead, ask the practitioner to walk through an actual recent case: what triggered it, what they looked at, what they did, and what came out. Record the input, the result and the next responsible role at every handoff. Real cases surface details that generalities hide, such as the second spreadsheet nobody mentioned.

3. Ask why at every fork

Wherever the person chooses between options, stop. Ask what they were weighing, what would have changed their mind, and what they have seen go wrong. This is expert elicitation, closer to an oral-history interview than to a form. The answers are the load-bearing parts of the procedure: remove them and everything above collapses the first time reality diverges.

Where it goes wrong: experts compress. They skip steps that feel obvious to them, which are exactly the steps a newcomer lacks. A useful countermeasure is to have someone who does not know the process do the recording, because they will keep asking what the expert would never think to say.

This is the step where our approach does the heavy lifting. Kept supports guided interviews that draw out exceptions and reasoning, so the person describes the work in their own words and the platform structures it into a workflow. Nobody has to sit in a conference room reconstructing the details weeks later.

4. Keep a running list of exceptions

During the first walkthrough, park exceptions rather than chasing each one, so the main flow stays clear. Then return to the list and ask, for each: who handles it, what happens next, who owns the step and where the handoff occurs. Ask directly about the times the process did not work, and the times a rule was bent on purpose. Those stories are the richest context you will get.

In Kept, capture is opt-in and the person can review and delete what was recorded. That matters in practice, because people share judgment more freely when they stay in control of what is kept.

5. Structure it so someone else can use it

Raw notes are not documentation. Turn each captured case into three linked pieces: the sequence (who, what, when), the instruction (inputs, checks, permitted actions) and the judgment (decisions, exceptions, reasons). For a deeper look at running this as a workshop, see our guide to process mapping and decision capture, and for the end-to-end method, seven steps to process documentation that keeps decisions.

Three linked parts of process documentation

6. Have a second person test it

Give the draft to someone who has never done the work and ask them to handle a past case using only the document. Wherever they stall, context is missing. Fix it, and repeat. This is how you verify the document rather than assume it.

Organizing context so people can find it

Capturing is half the job. If a new employee cannot find the right paragraph at the right moment, it might as well not exist.

  • Link, do not merge. Overview, instruction and judgment should reference each other and stay consistent as versions change.
  • Attach context to the activity. The exception note belongs beside the step it affects, not in a separate archive. This is the ACKNOWLEDGE principle: knowledge linked to the activity where it will be needed.
  • Make it searchable by situation. People search with the problem in their head ("customer paid twice"), not with your document title. Kept offers context-aware search and answers that cite the passages they come from, so a newcomer can see where an answer originated.
  • Control who sees what. Process knowledge often touches contracts, pricing or personnel matters. Workspace-level access controls let a team share what it should and nothing more.

For onboarding specifically, the same logic applies. Onboarding process documentation works when it carries the reasons behind each task, and our engineering onboarding guide shows what that looks like for technical teams.

Keeping process context current

Context decays. Systems change, a vendor is replaced, a rule is rewritten, and the document keeps describing last year's reality. TIMBUS recommends modeling context systematically, retaining metadata and provenance, and checking a reconstructed process against the original, refining the model whenever a relevant aspect turns out to be missing. In a company, that translates into habits:

  1. Assign every document an owner. An unowned page is already out of date.
  2. Make documentation part of "done." When a process changes, the change is not finished until the document reflects it.
  3. Set a review rhythm that matches the speed of change. Fast-moving runbooks may need monthly checks, process and onboarding guides quarterly ones, and the whole knowledge base an annual audit. Adjust to your own pace.
  4. Log changes with the reason. The audit trail should say what changed and why. Our pieces on audit-ready change documentation and process change control cover this in depth.

For more on keeping process documentation current as practices evolve, a short audit of what is written down versus what is actually done is a good place to start.

Let new-hire questions find the gaps

Your newest employees are the best auditors you have. Every question a new person has to ask a colleague, instead of finding the answer in the knowledge base, marks a gap in your context. Keep a simple log of those questions during the first ninety days and feed them back to the owners. A good onboarding process shows how new-hire questions expose unclear documentation well before it turns into a mistake. You can also track what people search for and fail to find; our guide on measuring knowledge base usage starts with the first thirty failed searches.

A worked example: the refund that is not in the SOP

Imagine a small services company whose operations lead, Dana, handles refund approvals. The written SOP says: refund requests under a set amount are approved by the support agent; above it, by a manager. That is the entire document.

In a guided conversation about one real case, a different picture emerges. Dana explains that she checks whether the customer already received a credit this quarter, because the accounting system does not flag it. She waives the threshold for annual-contract customers, since finance prefers to avoid churn on those. And if the request arrives in the last two days of the month, she holds it, because the reconciliation closes and a late reversal creates cleanup work.

A worked example: the refund that is not in the SOP

None of that was in the SOP. Captured as context, it becomes three exceptions, three reasons and two checks. A replacement now has what Dana carries in her head. More usefully, the team can argue about whether those rules are right, which they could never do while the rules were invisible.

Perspective: why we think context is the product

Most documentation tools ask people to write like a manual. The manual comes out clean, and it comes out wrong, because the person who knows the work does not think in numbered steps. They think in judgment calls.

We have watched the same pattern repeat: the SOP covers the rule, and the exceptions live in someone's head until they leave. Then the team discovers how much of the procedure was ceremony and how much was load-bearing.

That is why we built Kept around conversation. When people describe their work in their own words, with a guide asking the questions a good interviewer would ask, the reasons come out along with the rules. Exceptions get named. Context is preserved rather than flattened.

We also think the person whose knowledge is being captured should stay in charge of it. Opt-in capture, review and deletion are not features we added for comfort. They are the reason people speak honestly.

If you are going to invest in documenting a process, document the part that is hard to replace.

Anthony

Put it to work with Kept

If you want process context captured without turning it into a months-long documentation project, Kept gives you a place to do it. Team members describe their processes in conversation, guided interviews draw out exceptions and reasoning, and the result is structured workflows your team can search and cite. Kept has plans for individuals (kept for you) and for teams (kept for business, with workspace-level access controls). You can see how it fits onboarding on the Onboarding use case page, take the quick tour of the app, or look at the plans on the pricing page.

Kept

FAQ

What is the difference between a process and its context?

A process is the general description: who does what, in what order and why. Context is what those elements mean for a particular case, including the data, roles, conditions and exceptions that determine the path the work takes. The process is the map; the context is the terrain.

How much process context is enough?

Capture enough that a competent newcomer could handle your last three unusual cases without calling the original expert. Start with decisions and exceptions, then add dependencies, stakeholders and data. If a second person tests the document and still stalls, something is missing.

Who should capture process context?

The practitioner supplies it, but it works best when someone else does the asking. A person unfamiliar with the work raises questions an expert would skip. A guided conversational tool can play that role, so the practitioner does not have to write anything from scratch.

How often should captured context be reviewed?

Match the review rhythm to how quickly the process changes. Fast-changing procedures may call for monthly checks, onboarding and process guides for quarterly ones, and the full knowledge base for an annual audit. Every document should have a named owner responsible for those reviews.

Does capturing context only matter when someone leaves?

No. It helps every time work is handed over, audited or taught: onboarding, vacation cover, process changes and compliance reviews. Departures simply make the cost of missing context visible all at once.

Sources