Stop Fighting Requirements: How Your Small Dev Team Can Master Traceability for $0

Stop Fighting Requirements: How Your Small Dev Team Can Master Traceability for $0 (with Git & Google Sheets)

After a decade in embedded systems, I've seen countless engineering teams struggle with requirements management tools. For large enterprises, complex systems might justify expensive, feature-laden platforms. But for small, agile teams, these tools often become a hindrance, not a help. My own experience, and industry data, confirms this systemic frustration:

• 73% of practitioners abandon traceability due to tool complexity [1]
• Manual methods fail when managing beyond ~200 requirements [2]
• ReqIF-based workflows require 40% more review time than alternatives [3]

As a Provisional Automotive SPICE assessor, I spent years teaching the value of traceability, structured authoring, and disciplined processes. Yet, in my own side projects, I ignored these very best practices. Why? Because the tools felt decades outdated, prioritized auditors over engineers, made simple tasks needlessly complex, and were simply too expensive for lean operations.

The Immediate Fix: Achieving Rigor Without the Price Tag

You don't need a massive budget or a complex enterprise solution to achieve robust requirements management and even pass ISO audits. For small teams, simplicity, adaptability, and automation are key. Here’s how you can implement bi-directional traceability today using tools you already have: Google Sheets, Git, and good process hygiene.

✅ Step 1: Your Agile Traceability Matrix in Google Sheets

Create a simple, auditable table like this in Google Sheets or Excel. This becomes your single source of truth for requirements.

• ID: Unique requirement reference (e.g., REQ-###).
• Description: The functional intent of the requirement.
• Verified In: A direct hyperlink to a test, validation artifact, or code that implements/verifies this requirement.
• Depends On: Traceability to upstream requirements (optional, but good for understanding dependencies).

💡 Advantages for Small Teams:

• Live hyperlinks ensure real-time traceability to tests/code.
• Auditable without special software, making compliance light.
• Lightweight and adaptable to your team's specific workflows and rapid changes.

⚙️ Step 2: Automate with Git for Continuous Validation (The Dev's Best Friend!)

This is where the magic happens for developers! Maintain consistency and prevent requirements drift by adding a lightweight Git pre-commit hook. This acts as an automated gatekeeper, enforcing test coverage against declared requirements before code is merged.

Create a file named pre-commit in your .git/hooks/ directory within your repository (make it executable with chmod +x .git/hooks/pre-commit):

#!/bin/bash

# Define the pattern for your requirement IDs
REQ_PATTERN='REQ-[0-9]\+'

# 1. Extract unique requirement IDs from your requirements file (e.g., requirements.reqif or traceability.csv)
#    Make sure to adjust 'requirements.reqif' to your actual file path (e.g., 'traceability.csv')
REQS=$(grep -o "$REQ_PATTERN" requirements.reqif | sort -u)

# 2. Recursively search for requirement IDs referenced in your 'tests/' directory
#    This assumes your test files explicitly mention the REQ-IDs they cover.
TESTS=$(grep -r "$REQ_PATTERN" tests/ | grep -o "$REQ_PATTERN" | sort -u)

# 3. Compare the two lists to find requirements that are in REQS but NOT in TESTS
#    'comm -23' shows lines unique to the first file.
MISSING=$(comm -23 <(echo "$REQS") <(echo "$TESTS"))

# 4. Check if any requirements are missing test references
if [ -n "$MISSING" ]; then
  echo ""
  echo "❌ Missing test references for the following requirements:"
  echo ""
  echo "$MISSING"
  echo ""
  echo "Please ensure all listed requirements are covered by tests."
  echo "Commit aborted."
  exit 1 # Exit with a non-zero status to prevent the commit
fi

echo "✅ All requirements are covered by test cases. Committing..."
exit 0 # Exit with zero status to allow the commit

💡 Why This Matters for Dev Teams:

• Prevents unverified requirements from creeping into your codebase – an automated safety net.
• Acts as an automated guardian to maintain trace-test alignment. No more manual checks!
• Can be extended to enforce naming standards, dependency checks, or status flags, building disciplined processes without bureaucracy.
• Integrates directly into your workflow – no external tools or dashboards needed initially.

🔎 Step 3: Weekly Audits Made Simple

Transform your spreadsheet into a dynamic audit tool. Once a week (or before major releases), simply filter your traceability sheet to quickly find coverage or dependency gaps:

• Filter “Verified In” = BLANK → to find untested or unverified requirements.
• Filter “Depends On” = #REF! or invalid IDs → to catch broken dependency chains.

💡 Why This is Effective:

• Enables lightweight traceability audits without heavy tooling.
• Helps keep everyone accountable for test coverage and requirement completeness.
• This minimal setup scales up to ~200–300 requirements before things get too noisy [2]—perfect for many small projects.

Beyond Spreadsheets: When to Consider Dedicated Tools Like Ellygent

This minimal setup is powerful for lean teams. It's fast, auditable, and effective. However, as projects grow in complexity or team size, manual methods can become cumbersome. This is where Ellygent (https://www.ellygent.com) comes in.

Ellygent is my personal project born from the need to bridge the gap between structured systems engineering and the agile, fast-paced workflows small teams demand as they scale. It offers the rigor and compliance of enterprise tools, but with the speed and flexibility of modern dev tools.

It’s built for teams that need:

• ✓ Compliance without bureaucracy
• ✓ Speed without technical debt
• ✓ A Requirement SME as your "Co-pilot"

Ellygent's Core Features: Scaling Your Best Practices

Ellygent builds upon the principles of the $0 solution, offering more advanced capabilities designed for developers:

• ✍️ Browser-based editor: No more Java nightmares, just clean, intuitive editing.
• 📸 Git-like versioning: This goes beyond simple file history, directly addressing the 60% link decay that plagues manual systems [2] by maintaining robust traceability across versions automatically.
• 🔗 Visual traceability (coming Q3): Gain immediate, interactive insights into complex dependencies, far beyond what a spreadsheet can offer.
• 🧠 AI-assisted requirements: Get smart help with authoring, reviewing, and scored feedback to refine your requirements faster and ensure quality at scale.

Now Open-Sourcing Key Components

As part of Ellygent’s gradual release plan, I’ll be open-sourcing key components in 2025. These initial tools are the core building blocks that helped me most in my own projects—and could be fast-tracked for earlier release depending on interest:

• 🔧 ReqIF Diff CLI: Semantic change detection between versions – a developer's dream for understanding requirement changes.
• 📊 SpecObject Tracker: Alerts on requirements drift and changes.

Let’s Connect & Discuss!

I truly believe that requirements management doesn't have to be a painful bottleneck. If you:

• Want to get your hands on the template spreadsheet
• Need help implementing these Git hooks
• Are hitting limits with manual methods and want to explore how Ellygent can help you scale effectively
• Just want to discuss requirements engineering challenges in general!

...drop a comment below, or reach out. I’m happy to share what I’ve learned and explore what works in practice.

Thanks for reading!

References

[1] Méndez Fernández et al. (2020)
[2] IEEE RE Conference Proceedings (2018)
[3] Springer Conference on Automated Software Engineering (2019)

Disclaimer: This is a personal project. My views and tools are my own and not affiliated with any employer. This project is developed outside of work hours without using employer resources or confidential information.