BA practice

Assumptions log: how to turn every assumption into a requirement, a test or a risk before sign-off

By Prachit Parikh, business analyst · · 17 min read

Picture the last requirements sign-off before the holidays. The document is forty pages long, the sponsor has twenty minutes, and on page six there's a section called Assumptions. "The client will provide test data." "Existing user roles will be reused." "The vendor API supports bulk updates." Nobody objects. Everyone signs. Three weeks into the build, one of those lines turns out to be false, and it was holding up half the design.

Writing assumptions isn't the mistake. You have to write them, because nobody can wait for every fact before starting. The mistake is treating the assumptions section as a disclaimer, a polite list of things you didn't get round to checking. It works far better as a work queue. This post is how I'd run one, with a template, a filled example on a fictional client, and an AI pass for the assumptions nobody wrote down.

The short version fits on a sticky note. Every assumption becomes a question with a named owner and a date. Before sign-off, every one of them leaves the log as a confirmed requirement, a test or a named risk. There's no fourth option.

Why assumptions sink projects

The biggest dataset I know of on this is Bent Flyvbjerg's. He and Dan Gardner built How Big Things Get Done on a database of more than 16,000 projects. In an interview with Mind Tools, Gardner gives the numbers: a little under half come in on budget, about 8.5% come in on budget and on time, and only 0.5% hit budget, schedule and the promised benefits. Their prescription is "think slow, act fast": slow, careful planning that reveals problems while they're cheap. An unexamined assumption is exactly that kind of problem.

PMI's 2026 Pulse of the Profession, Driving Success in Complex Projects, was announced in May 2026. It says 31% of complex projects fail to achieve the full scope of their intended benefits, and that "only one in five practitioners" use scenario planning. Scenario planning is, at heart, asking "what if this thing we believe is wrong?" before it's expensive. Most teams skip it.

On the requirements side, the NaPiRE survey (Naming the Pain in Requirements Engineering) asked practitioners what hurts. In the summary paper by Méndez Fernández and colleagues, covering 228 companies in 10 countries, incomplete requirements are "the most frequently stated problem", ahead of communication flaws with the customer. The data is from 2014/15, so read it as a long-standing pattern. I'd argue many incomplete requirements started life as assumptions: things someone was so sure about that nobody wrote them down.

None of these sources says "assumptions caused X% of failures," and I won't claim it. What they show is that most projects miss a promise, teams rarely test their beliefs early, and missing requirements are the top complaint. A worked assumptions log is a cheap fix for all of that.

A wall covered in sticky notes from a planning session
Every one of these notes is a claim somebody believed. Photo by Annie Vo, Unsplash License.

An assumption is a question nobody has asked yet

Start by rewriting each assumption as a question. "The vendor API supports bulk updates" becomes "Does the vendor API accept more than one record per call, and what's the limit?" A question looks unfinished in a way a statement doesn't, and it tells you who can answer it.

The rewrite usually exposes that one assumption is really two or three. "Credits over a threshold need manager approval" hides at least three questions. What's the threshold? Is it per credit or per customer per month? Who approves when the manager is on leave?

Then give the question an owner and a date.

The owner is a named person, never a team. "IT" can't answer a question. Dana from integrations can, and Dana can be chased. If you can't find a person, that's a finding: nobody owns this fact, so nobody will notice when it changes.

The date is when you need the answer, worked back from the moment a wrong answer starts costing rework. If the bulk-update question decides whether you design a batch screen, the date falls before design review, not before UAT. Next to it, write why that date: the decision that depends on the answer. It's the column people skip, and it matters most when you're chasing a late reply. "Please reply" gets ignored. "Design review is Thursday and this decides the approval screen" gets an answer.

Question, owner, date, reason. That's the method. The rest is bookkeeping.

Three exits, and only three

Before sign-off, every row in the log has to leave by one of three doors.

It becomes a confirmed requirement

The owner answered, the answer is something the system has to do or respect, and it moves into the requirements set with a trace back to the log row. "The API accepts up to 200 records per call" is now a constraint the design must honour. If the answer is "no," that's still this exit: the corrected fact becomes the requirement, and the design gets a change note.

It becomes a test

Some assumptions can't be confirmed by asking, only by trying. "Records migrated from the old system have no duplicate customer IDs" is one. The data owner can say yes in good faith and still be wrong. So it becomes a check in the test plan, with an expected result and an agreed action if it fails. My post on SQL data profiling on a brand-new table is full of assumptions that should have been tests.

It becomes a named risk

Some questions can't be answered in time, or the honest answer is "we won't know until go-live." That's fine, as long as it's written down as a risk with an owner, a likely impact and a fallback. A sponsor who signs off on a named risk has made a decision. A sponsor who signs off on an unexamined assumption has just signed.

There's no fourth door marked "still assumed." If a row is open at sign-off, either the sign-off waits or the row is reclassified as a risk in front of the people signing.

Which exit? A decision table

People get stuck choosing between test and risk, or quietly park everything as a risk because it's less work. Read this table top to bottom and take the first rule that matches. (I used the same first-match style for choosing a split pattern for user stories.)

RuleOwner's answerCan it only be proven by running something (data, interface, volume)?Impact if wrongExit
1"No, that's not true"AnyAnyRequirement (the corrected fact), plus a change note on the affected design and estimate
2Confirmed, with evidenceNoAnyRequirement, traced to the log row
3Confirmed, with evidenceYesAnyRequirement plus a test that proves the answer holds in the real data or interface
4Can't be known until it's triedYesAnyTest, run before the decision date if it drives design, otherwise before UAT entry
5Can't be answered before the needed-by dateNoHighNamed risk with owner, impact and fallback, raised at sign-off
6Can't be answered before the needed-by dateNoLowRisk, accepted, with the sponsor's name on it

"Confirmed, with evidence" means something checkable: a sample file, a query result, a versioned policy. For anything expensive, an email saying "yes, that's fine" gets rule 3 and a test anyway. For "impact if wrong," ask one blunt question: if this is false in week six, do we redesign something or just fix a value? Redesign is high.

The assumptions log template

These columns fit in any spreadsheet, Confluence table or Jira issue type.

ColumnWhat goes in it
IDASM-01, ASM-02. Never reuse one.
Assumption as statedThe original words and where they came from.
Rewritten as a questionOne question per row.
OwnerA named person, not a team.
Answer needed byA date, worked back from the decision.
Why that dateThe decision that depends on the answer.
Impact if wrongHigh (redesign) or low (fix a value).
Answer and evidenceWhat the owner said, plus a link to the proof.
ExitRequirement, test or risk.
Linked IDThe requirement, test or risk ID it became.
StatusOpen or closed.
Date closedWhen it left the log.

Twelve columns sounds heavy, but most rows take two minutes once the owner answers. The columns that take thought are the ones doing the work.

If you'd rather paste it straight into a sheet, here's the header row:

id,assumption_as_stated,source,question,owner,needed_by,why_that_date,impact_if_wrong,answer_and_evidence,exit,linked_id,status,date_closed

A filled example: Northstar Systems

Here's an invented example. Northstar Systems is a fictional company, and none of these people, figures or events describe a real project or client.

Northstar wants to replace a spreadsheet its billing team uses to approve customer credits. The draft requirements carry four assumptions: a manager approves credits over a threshold, finance can take a nightly file, every billing user already has an account, and the credit reasons won't change. Two more turned up later (see the AI section). Here's the log on sign-off day.

IDQuestionOwnerNeeded by (why)Answer and evidenceExitLinked ID
ASM-01What's the approval threshold, is it per credit or per customer per month, and who approves when the manager is out?Maya Chen, billing manager14 Jan (design review decides the approval screen and routing)$500 per credit; deputy approves when Maya is out. Policy v3 attached.RequirementREQ-011, REQ-012
ASM-02Does the finance system accept a nightly credit file, in what format, and what's the cutoff?Tom Alvarez, finance systems lead14 Jan (decides export file or API build)Yes. CSV per spec v2, 9 PM ET cutoff. Sample file loaded in test.Requirement + testREQ-020, TC-031
ASM-03Does everyone on the billing roster have an active account with the right role?Priya Nair, billing operations lead1 Feb (UAT entry)Only checkable by comparing roster to user list. First run found 2 missing; fixed, rerun clean.TestTC-044
ASM-04Will the credit reason codes change before go-live?Tom Alvarez21 Jan (reason list build)Unknown. Finance's code review ends in March, after go-live.RiskRSK-03
ASM-05Can a manager approve a credit they requested themselves?Sam Okafor, controller14 Jan (approval routing)Never. Audit requirement; policy section 4.2.Requirement + testREQ-013, TC-022
ASM-06What's peak daily credit volume, including month-end?Priya Nair21 Jan (performance test sizing)Past peak 140 a day; future unknown, but far below the tool's limits.Risk, acceptedRSK-05 (accepted by Lena Ward, VP Finance)

ASM-01 became two requirements because the rewrite split it. Requirement counts usually go up after an assumptions review. That isn't scope creep. The scope was always there; it just wasn't written down.

ASM-04 is the interesting one. Nobody could answer it before go-live and the impact is real, so it's rule 5. RSK-03 names the owner, what breaks, and the fallback: go live with today's list and add codes as configuration later. The sponsor read that at sign-off and agreed. That's a decision. "Credit reasons will stay the same" would have been a hope.

ASM-06 shows the lighter path: low impact, straight to "risk, accepted" with a name on it.

Six assumptions went in. None were still assumptions at sign-off.

A check that returns rows only when something's wrong

Manuel Diaz, commenting on my Dev.to post on SQL checks before UAT sign-off, suggested writing every check as a query that returns rows only when something is wrong. It works for the log too. If yours lives anywhere you can query, this is the sign-off gate:

SELECT id,
       CASE
         WHEN owner IS NULL THEN 'no owner'
         WHEN owner LIKE '%team%' THEN 'owner is a team, not a person'
         WHEN exit_type IS NULL THEN 'no exit chosen'
         WHEN linked_id IS NULL THEN 'exit has no linked ID'
         WHEN status = 'open' THEN 'still open'
       END AS blocks_signoff_because,
       needed_by
FROM assumptions_log
WHERE owner IS NULL OR owner LIKE '%team%' OR exit_type IS NULL
   OR linked_id IS NULL OR status = 'open'
ORDER BY needed_by, id;

Here's the output against Northstar's log as it stood at the walkthrough on 8 January, a week before design review (run in SQLite 3.53.1 through Python's sqlite3 module):

id      blocks_signoff_because         needed_by
------  -----------------------------  ----------
ASM-02  no exit chosen                 2027-01-14
ASM-05  no owner                       2027-01-14
ASM-04  owner is a team, not a person  2027-01-21
ASM-03  still open                     2027-02-01

Four rows, sorted by the date they're needed: the agenda for the next stand-up. On sign-off day the same query returned nothing, which is the only result that should let a sign-off go ahead. The LIKE '%team%' line is crude (add your own team-shaped names), but it caught ASM-04 being owned by "Finance team."

How the log plugs into UAT and the traceability matrix

A log in its own spreadsheet gets forgotten the week after sign-off. Wire its exits into documents people already use.

The traceability matrix

Every requirement that came from the log should say so. My traceability matrix template has a source column. For REQ-011, the source is "ASM-01, credit policy v3" rather than "billing workshop." When someone asks in month four why the threshold is per credit, the trace takes them to the question, the owner and the evidence. Tests from the log go in test_case_ids, so TC-031 sits next to REQ-020.

Requirements from the log need acceptance criteria like any other. "Credits over $500 route to a manager" needs criteria for exactly $500, $500.01 and the deputy path. My acceptance criteria template has the format, and I walk through how to write criteria a tester can't misread in this video:

Video: "How to Write Acceptance Criteria Testers Can't Misread", Prachit Parikh. More on my YouTube channel.

UAT entry criteria

My UAT plan template lists entry criteria that must all be true before UAT starts. I'd add two:

The second matters more than it looks. New assumptions slip in after sign-off, and if they're open at UAT entry, testers will test the requirements and miss the beliefs underneath.

UAT exit criteria

And two for the exit side:

My Substack post on what a good UAT plan actually looks like covers why those criteria get decided up front.

A hand marking off items on a paper checklist
An entry criterion is a checkbox that someone has to be able to tick honestly. Photo by Jakub Żerdzicki, Unsplash License.

Using an AI assistant to surface hidden assumptions

The assumptions in the document are the easy ones. The dangerous ones are in the meeting notes, said once and never written down. "Obviously managers won't approve their own credits." Nobody logs those, because they didn't sound like assumptions when they were said.

An AI assistant is decent at this job, with limits. Here's the prompt I'd start from. Paste one meeting's notes at a time, and only into a tool your company has approved for that content.

You are helping a business analyst find unstated assumptions in meeting notes.

Read the notes below. List every statement that someone treated as true
but that nobody confirmed, and every decision that depends on something
outside this team's control.

For each one, give:
1. A verbatim quote from the notes (copy it exactly, no paraphrase)
2. The assumption it reveals, in one sentence
3. The assumption rewritten as a question someone could answer
4. Whether it's about a business rule, data, an interface, people, or volume

Rules:
- If you can't point to a verbatim quote, don't list it.
- Don't suggest owners, dates or answers.
- Don't add numbers, names or thresholds that aren't in the notes.
- If two items are the same assumption, merge them.

Notes:
[paste one meeting's notes here]

In the Northstar example, that's how ASM-05 turned up. Somebody said managers "obviously" wouldn't approve their own credits, and nobody had asked the controller. As a question it went to Sam and came back as an audit rule, a requirement and a negative test. ASM-06 came from a throwaway line about month-end being "busy but fine."

The checks to run on what it gives you

Don't paste the output into the log. Run these first.

Find every quote. Search the notes for each verbatim quote. If you can't find it, delete the item. A model told to quote will sometimes produce something quote-shaped that nobody said.

Check the transcript itself. If the notes came from automatic transcription, the source can be wrong before the assistant sees it. A Cornell-led study presented at FAccT 2024, "Careless Whisper", ran more than 13,000 speech clips through OpenAI's Whisper and found that roughly 1% of transcriptions contained entire hallucinated phrases. One percent is small until it's the sentence your threshold rests on. For anything about to become a requirement, check the recording or ask the speaker.

Assume it missed things. In ReqElicitGym, a February 2026 evaluation of how well LLMs draw out users' implicit requirements in elicitation interviews, the best model managed an implicit-requirement elicitation score of only 0.32 across 101 scenarios and 632 annotated implicit requirements. That's a different task from reading notes, so don't carry the number across. But the direction is clear: these models find some of what's unsaid, not most. Read the notes yourself first, then run the assistant, then compare lists.

Keep owners and dates human. An assistant will happily write "Owner: IT" and "Needed by: before UAT," the exact vagueness this method exists to kill.

Check the rewrite kept the meaning. A question that adds a number or narrows the scope has changed the assumption. "Will reason codes change?" is fine. "Will finance add the three new reason codes in February?" invented two facts.

Run it again on the same notes. If the second list is very different, treat both as prompts, not findings. Same idea as in AI agent testing: a result that changes between runs isn't a result yet.

Used this way, the assistant is a second reader with no memory of what was "obvious" in the room. It doesn't replace asking the questions.

The take you might disagree with

An assumption with no owner is a requirement you've already agreed to without reading it. And by sign-off day, the assumptions section of a requirements document should be empty.

Plenty of analysts treat the assumptions list as a courtesy. But look at what happens once the document is approved. Every unowned assumption gets built as if it were true. Developers design around it. Testers don't test it, because it isn't a requirement. And when it breaks, catching it was nobody's job. It was a requirement all along that never got reviewed like one.

The fair counterargument: on a two-week change, chasing every row is overhead. Half right. Keep the log, move low-impact rows straight to "risk, accepted" with the sponsor's name (rule 6), and chase only the rows that would force a redesign. Another objection is that an empty assumptions section looks overconfident. I'd say the opposite. A document whose assumptions all became requirements, tests or named risks is showing its working. A long "we assume" list shows the work wasn't done.

What the method misses

Owners can be confidently wrong. That's why rule 3 exists. "Yes, that's fine" in an email is an answer, not evidence.

The log goes stale. New assumptions arrive in change requests and build questions. Arjun Sharma asked a question on my Dev.to post that led to the same rule for data checks: rerun them after every refresh, not once. Same here. Review the log at every walkthrough, at UAT entry and before go-live.

It can become theatre. If every row goes to "risk, accepted" because it's quicker, the log is the old section with more columns. The real check is the sponsor reading the risk rows out loud. If they can't explain a risk, they didn't accept it.

Some assumptions are about people. "The billing team will stop using the spreadsheet" can't be fully tested. It ends up as a risk with a change management fallback, and that's honest.

It doesn't catch what nobody said at all. The AI pass only covers things said in meetings. Gary Klein's pre-mortem ("it's six months from now and this failed; why?") is the best tool I know for that, and its output goes straight into the log as new rows.

What I'd do on Monday

  1. Copy every assumption from the document you're closest to signing off into a sheet with the twelve columns above.
  2. Rewrite each as a question. Split the compound ones. Expect the count to go up.
  3. Put a person's name, a needed-by date and the reason for that date on every row. No person? Flag it today.
  4. Run your last two workshops' notes through the prompt, do the quote check, and add the survivors.
  5. Run the decision table on every answered row, and put the log ID in your traceability matrix's source column.
  6. Add the two entry criteria and two exit criteria to your UAT plan.
  7. At the next walkthrough, read the open rows out loud, earliest date first.

That's a morning's work, and it turns a page nobody reads into the list of things most likely to hurt you.

If you're splitting stories too, watch for assumptions hiding in the slices; my post on how to split user stories covers that. My portfolio page has case studies on the same fictional Northstar client.

Discussion questions

Comment prompt: Tell me the one column you'd add to this template, or the one you'd cut. If you run an assumptions log already, I'd really like to know how you stop it going stale after sign-off.

References

  1. Dan Gardner interviewed by Mind Tools, How Big Things Get Done (on Bent Flyvbjerg and Dan Gardner's book and the 16,000-project database).
  2. Project Management Institute, Why Complex Projects Fail: Best Practices Are Not Enough, System Thinking Gives Your Team the Edge, press release for Pulse of the Profession 2026, Driving Success in Complex Projects, Business Wire, May 2026.
  3. Daniel Méndez Fernández et al., Supporting Requirements Engineering Research that Industry Needs: The Naming the Pain in Requirements Engineering Initiative, arXiv:1710.04630 (NaPiRE data from 2014/15).
  4. Louis DiPietro, AI speech-to-text can hallucinate violent language, Cornell Chronicle, 11 June 2024, on Koenecke et al., "Careless Whisper: Speech-to-Text Hallucination Harms," ACM FAccT 2024.
  5. Dongming Jin, Zhi Jin et al., ReqElicitGym: An Evaluation Environment for Interview Competence in Conversational Requirements Elicitation, arXiv:2602.18306, 20 February 2026.

Reader lessons used: Manuel Diaz, checks that return rows only when something is wrong; Arjun Sharma, a question that led to rerunning checks after every refresh (both on my Dev.to post).

All my links in one place: my profile hub and my portfolio.

About me

I'm Prachit Parikh, a business analyst. I turn what stakeholders ask for into requirements a team can test, check the data with SQL, and see changes through UAT. I keep free templates, including the UAT plan and traceability matrix this log plugs into, in my BA Toolkit on GitHub, and I make short animated explainers on YouTube. Besides this site, I write on Substack, Medium, Hashnode, Dev.to, Blogger and WordPress, and I answer questions on Quora. You can also find me on LinkedIn, Bluesky, Kaggle, Credly, Crunchbase and Gravatar. Everything is collected on my website and my profile hub.

← More articles by Prachit Parikh