Business Requirements Document Template: Free Markdown BRD

November 11, 2026 · 14 min read

Business Requirements Documentation Template: BRD and SRS in Markdown

A business requirements documentation template gives every project the same skeleton: why the work matters, what's in scope, numbered requirements, and how you'll prove each one is met. Below you'll find a copy-paste BRD in Markdown, a functional spec and SRS skeleton, testable wording patterns, and a traceability table.

What Is a Business Requirements Document?

A business requirements document (BRD) describes what a project must achieve and why, in business terms rather than technical ones. A business analyst or product owner usually writes it. The project sponsor signs it off before design starts.

It doesn't say what the software does or how it's built. The functional spec covers behaviour, and a design document covers the build. A product requirements document (PRD) is a close cousin that product teams use to describe features for one product. User-facing help pages are a different set of documents again. For those, use a product documentation template.

Starting from a business requirements documentation template saves you from the classic failure: a 30-page narrative where nobody can point at requirement 14 and ask whether it shipped. Numbered rows, named sources and acceptance criteria fix that.

What Is Functional Requirements Documentation, and How Is It Different From an SRS?

Functional requirements documentation turns each business need into behaviour the system must show: inputs, outputs, rules and error handling. A software requirements specification (SRS) covers the same behaviour and adds interfaces, data and non-functional targets such as speed and security. Here's how the three documents line up.

BRDFunctional spec (FRS)SRS
Question it answersWhy are we doing this, and what must the business get?What must the system do for each need?What must the software do, and how well?
Written forSponsor and business stakeholdersDevelopers, testers, analystsDevelopers, testers, architects, suppliers
Usually written byBusiness analyst or product ownerBusiness or systems analystSystems analyst or lead engineer
Level of detailOutcomes, rules, scopeBehaviour per featureBehaviour plus interfaces, data and quality targets
Sample lineBR-01: Customers can request a refund without calling supportFR-1.1: The system shall list refundable items on the order pageNFR-03: The system shall confirm 95% of refund requests within 2 seconds

If you need a formal reference, ISO/IEC/IEEE 29148:2018 is the current international standard for requirements engineering. It replaced the 2011 edition, which itself superseded IEEE 830-1998, the older recommended practice for SRS documents.

Small teams rarely need three separate files. We'd write a short BRD and one merged functional spec and SRS, which is exactly what the two templates below give you.

The Business Requirements Documentation Template (Copy-Paste Markdown)

Copy this into a .md file, a wiki page or our editor, then replace everything in square brackets. We use square brackets rather than angle brackets because Markdown previews treat text like <Name> as an HTML tag and hide it. Numbered sections make review comments easy to place, for example "section 7, NFR-02 needs a number".

# Business Requirements Document: [Project name]

| Field | Value |
|-------|-------|
| Version | 0.1 (draft) |
| Date | [YYYY-MM-DD] |
| Author | [Name, role] |
| Status | Draft / In review / Approved |
| Approver | [Sponsor name] |

## 1. Executive summary
[Two or three sentences: the problem, who has it, and the outcome you want.]

## 2. Business objectives and success metrics
| Objective | Metric | Baseline | Target | By |
|-----------|--------|----------|--------|----|
| Cut refund calls to support | Refund calls per week | 1,200 | 300 | [date] |

## 3. Project scope
**In scope**
- [Process, channel or customer group this project changes]

**Out of scope**
- [Anything people might assume is included but isn't]

## 4. Stakeholders and sign-off
| Name | Role | Interest | Signs off? |
|------|------|----------|------------|
| [Name] | Sponsor | Budget and outcome | Yes |
| [Name] | Support lead | Call volume | No |

## 5. Current process and future process
**Today:** [How the work happens now, step by step.]
**After:** [How it works once this ships.]

## 6. Business requirements
| ID | Requirement | Priority | Source |
|----|-------------|----------|--------|
| BR-01 | Customers can request a refund without calling support | Must | Support lead |
| BR-02 | Finance sees every refund request in one daily report | Should | Finance |

## 7. Non-functional requirements
| ID | Requirement | Measure |
|----|-------------|---------|
| NFR-01 | Refund pages work on current mobile browsers | Latest two versions of Safari and Chrome |
| NFR-02 | Refund records are kept for audit | Retention period agreed with finance |

## 8. Assumptions, constraints and dependencies
- Assumption: [Something you believe is true but haven't confirmed]
- Constraint: [A fixed limit such as budget, date or regulation]
- Dependency: [Another team, system or vendor you rely on]

## 9. Glossary
| Term | Meaning |
|------|---------|
| [Term] | [Plain-language definition] |

## Revision history
| Version | Date | Author | Change |
|---------|------|--------|--------|
| 0.1 | [YYYY-MM-DD] | [Name] | First draft |

It renders as a titled document with a control table at the top, nine numbered sections, and a revision table at the end. Three parts get skipped more often than the rest:

  • Out of scope. Listing what you won't do stops the most common late argument. If someone assumes the refund project also covers exchanges, this is where you said no.
  • Success metrics. A target without a baseline can't be checked. "Fewer calls" isn't a metric; 1,200 calls a week falling to 300 is.
  • Revision history. This table is your change control. Every approved change bumps the version and gets one row, so you can always say which version the sponsor signed.

Writing Requirement Statements Your Team Can Test

A requirement is only useful if a tester can say pass or fail. Give each one an ID with a prefix that shows its level: BR- for business needs, FR- for functional behaviour, NFR- for quality targets. Never reuse a deleted ID, and keep one requirement per row. If a sentence contains "and", it probably holds two.

Use "shall" or "must" for anything mandatory. RFC 2119 defines MUST, SHALL, SHOULD and MAY as requirement levels for IETF specifications, and some teams borrow those capitals so the strength of each requirement is unmistakable.

For the wording itself, use the Easy Approach to Requirements Syntax (EARS). Alistair Mavin and colleagues at Rolls-Royce developed its handful of fixed sentence patterns:

- Ubiquitous: The refund service shall log every request.
- State-driven: While an order is in transit, the system shall hide the refund button.
- Event-driven: When a customer submits a refund request, the system shall show a confirmation within 2 seconds.
- Optional feature: Where the store sells gift cards, the system shall refund them as store credit.
- Unwanted behaviour: If the payment provider times out, then the system shall queue the refund and email the customer.

That renders as a five-item bullet list, one pattern per line. Here's the same idea applied to a vague requirement:

Before: The system should be fast and easy to use.

After:
- FR-1.3: When a customer submits a refund request, the system shall show a confirmation within 2 seconds.
- NFR-07: A first-time customer shall complete a refund request in under 3 minutes without help.

One vague line became two testable ones, each with a number someone can measure. For the Priority column, the MoSCoW method works well: Must have, Should have, Could have, Won't have (this time). Keep the Won't rows in the table. They record what you deliberately left out.

Functional Documentation Template for Software Projects (FRS and SRS)

When developers need more than the BRD, add this second file. It works as a functional documentation template on its own, and the interface, data and non-functional sections turn it into a lightweight software requirements documentation template as well.

# Functional Specification and SRS: [System name]

Version 0.1 | Traces to: BRD [Project name] v1.0

## 1. Purpose and scope
[What this system covers and which BRD requirements it serves.]

## 2. Users and system context
| User or system | What they do |
|----------------|--------------|
| Customer | Requests refunds from the order page |
| Payment provider | Receives refund instructions by API |

## 3. Functional requirements
### 3.1 Refund request (BR-01)
| ID | Requirement | Priority |
|----|-------------|----------|
| FR-1.1 | The system shall list refundable items on the order page. | Must |
| FR-1.2 | When a customer submits a request, the system shall email a confirmation within 5 minutes. | Must |

### 3.2 Finance report (BR-02)
| ID | Requirement | Priority |
|----|-------------|----------|
| FR-2.1 | The system shall produce a daily CSV of refund requests by 07:00 local time. | Should |

## 4. External interfaces
[APIs, file exports and other systems, with the format each one uses.]

## 5. Data requirements
[Fields stored, who owns them, how long they're kept.]

## 6. Non-functional requirements
| ID | Category | Requirement |
|----|----------|-------------|
| NFR-03 | Performance | 95% of refund requests confirmed within 2 seconds |
| NFR-04 | Availability | Refund page available 99.9% of each calendar month |
| NFR-05 | Security | Only the order owner and support staff can view a refund |
| NFR-06 | Accessibility | Refund flow meets WCAG 2.2 level AA |

## 7. Issues to resolve before sign-off
- [Question, owner, due date]

Each H3 under section 3 names the BR it serves, so nothing in the spec exists without a business reason. NFR numbering carries on from the BRD, so every ID stays unique across both files. Notice what's missing: architecture, components and technology choices. Those decisions belong in a separate design document, written after this one is agreed.

Acceptance Criteria as Checklists and Given/When/Then

Acceptance criteria tell you when a requirement is done. Put them directly under the requirement they test. For criteria a person checks by hand, a task list is the quickest format (our Markdown checkbox guide covers the syntax):

### BR-01 acceptance criteria
- [ ] A signed-in customer can start a refund from the order page
- [ ] The customer gets a confirmation email within 5 minutes
- [ ] Orders older than 30 days show the refund policy instead of the button

Each line renders as a checkbox. On GitHub, task lists in issues, pull requests and comments get checkboxes you can tick. Our editor's preview shows them as disabled checkboxes, so you tick them by changing [ ] to [x] in the text.

For criteria that will become automated tests, write them in Given/When/Then form. The Gherkin reference lists the keywords, including Feature, Scenario, Given, When, Then, And and But:

Feature: Self-service refunds

  Scenario: Refund requested inside the refund window
    Given a signed-in customer with an order placed 10 days ago
    When they request a refund for one item
    Then they see a confirmation message
    And they receive a confirmation email within 5 minutes

Cucumber matches each Given, When and Then line to a step definition in your test code, so the criterion runs as an automated check.

Here's a cut-down BRD with a requirements table and a checklist. Edit a row and watch the preview update:

BRD: Self-Service Refunds

Business requirements

ID Requirement Priority Source
BR-01 Customers can request a refund without calling support Must Support lead
BR-02 Finance sees every refund request in one daily report Should Finance

Acceptance criteria for BR-01

  • A signed-in customer can start a refund from the order page
  • The customer gets a confirmation email within 5 minutes
  • Orders older than 30 days show the refund policy instead of the button
97 words550 characters14 lines
Markdown

The table renders with its header and two data rows, and the criteria show as checkboxes with the last one ticked. When it looks right, export it to Word for the sponsor.

Tracing Each Requirement From Business Need to Test

A traceability table links every business requirement to the functional requirements that deliver it and the tests that prove them. One small table is enough for most projects:

| BR | FR | Test case | Status |
|----|----|-----------|--------|
| BR-01 | FR-1.1 | TC-101 Refundable items listed | Passed |
| BR-01 | FR-1.2 | TC-102 Confirmation email sent | Failed |
| BR-02 | FR-2.1 | TC-201 Daily CSV delivered | Not run |

Read across a row to see why a test exists. Scan the columns for gaps: a BR with no FR hasn't been specified, and an FR with no test case hasn't been proven.

One limitation: GFM tables have no syntax for merged cells, so BR-01 repeats on every row it covers. That's repetitive, but it keeps every row sortable. For the syntax, see our Markdown table guide. To skip typing pipes, build the grid in the Markdown table generator, which adds and removes rows and columns, sorts by any column, and outputs a GFM table.

How to Create a Requirements Document Step by Step

  1. Collect sources. Interview the sponsor and the people who do the work today, and gather tickets, complaints and reports.
  2. Settle the frame first. Fill sections 1 to 4 of your business requirements documentation template and get scope approved before writing a single requirement.
  3. Write BR rows, then FR rows. Every FR points to a BR, and every requirement gets acceptance criteria.
  4. Review it. Walk through it in a meeting or a pull request, one section at a time.
  5. Baseline it. Mark the approved version 1.0 in the revision history.
  6. Control changes. Each change request gets a new version number and a revision row.

We prefer keeping the BRD as a .md file in the repository next to the code. A pull request then shows exactly which requirement changed between 1.0 and 1.1, and who approved it. For broader advice on structuring docs, see our guide to writing documentation in Markdown. Need a proposal or meeting notes too? Our Markdown templates collection has short skeletons for those.

Sponsors often want a Word or PDF copy to sign. Paste the text into the editor and pick Export as DOCX or Export as PDF from the Download/Export menu. Free toolbar exports are capped at 5,000 characters, and a filled-in BRD can easily run past that. You can export it in parts, but each export spends one of the 3 free server operations a day. Pro removes both the character limit and the daily cap.

BRD Template FAQ

A business requirements documentation template only pays off when every requirement has an ID, a priority, a source and a way to prove it's done. Copy the BRD above, add the functional spec when developers need more detail, and keep the traceability table current as tests run. Paste your draft into the editor to check the tables and checklists render, then export a Word copy for sign-off.