For too long, software testing has been perceived as a necessary evil—something that slows teams down, adds overhead, or worse, can be postponed indefinitely. But the reality is this: the longer you delay quality, the more it costs you.
As modern teams embrace Agile, DevOps, and Continuous Delivery, testing needs to evolve from being a final checkpoint into a built-in practice. One of the most impactful ways to do this? Build test automation directly into your Definition of Done.
The Testing Bottleneck Is Real—and Automation Isn’t the Cure If It’s Delayed
Automation is often seen as the answer to speeding up quality assurance. And it can be—when it’s done during development. But in many teams, writing automated tests becomes an afterthought. It’s labeled as “nice to have,” slotted into a backlog, and eventually buried under the weight of new features and deadlines.
What happens then?
-
Critical features go untested.
-
Automation debt builds up fast.
-
Testers rush to write entire suites after the code is live.
-
Teams begin the next sprint, and automation just doesn’t happen.
Automation work, ironically, becomes the new bottleneck.
The Shift: Make Test Automation Part of the Ticket
To avoid this, we recommend redefining what “Done” means for each piece of work. At Digital Archer Development, we encourage teams to treat test automation as an essential task—not a separate one. A story or bugfix is not “Done” until:
✅ The feature is implemented
✅ It’s manually tested
✅ Automation steps are written for relevant scenarios
This reframes test automation as a core development activity, not a bonus. It gets tracked, prioritized, and delivered as part of the sprint—not later.
Why This Works
-
No More Last-Minute Automation Crunch
You’re not scrambling to build tests after go-live. Tests are already part of the build. -
Reduced Technical Debt
Automated coverage evolves with the codebase—preventing gaps from piling up. -
Team-Wide Accountability
Developers and testers share responsibility for automation. Quality is everyone’s job. -
Improved Long-Term Velocity
Less regression testing overhead in future sprints and more confidence with each release.
But Isn’t That a Lot of Extra Work?
Not if you break it down properly.
Instead of writing complete end-to-end tests upfront, only automate the part relevant to the current change. For example, if a feature updates a dropdown field, only test that logic—not the full user journey. Over time, these smaller steps grow into robust automated suites.
This micro-automation approach keeps velocity high and makes test writing manageable.
“Automation isn’t about replacing humans—it’s about empowering teams to build quality into every step.” — Lisa Crispin & Janet Gregory, Agile Testing
Best Practices for Making This Work
-
Plan Tests Early
During refinement, identify what’s testable and what can be automated. This way, developers and testers can align on coverage expectations early on. -
Collaborate Across Roles
Testers can draft test structures or pseudocode before the implementation starts. Developers can review or contribute to test code to ensure accuracy and efficiency. -
Don’t Wait to Start
Even before a feature is coded, automation scaffolding (like data setup or mock objects) can be prepared. This drastically speeds up test implementation. -
Track Automation Progress
Include automation status in daily standups or sprint boards. If a ticket is blocked on tests, treat it as a real blocker. -
Communicate Early & Often
If time is tight, speak up. Teams can pair on tests, reassign tasks, or re-scope stories before things fall through the cracks.
Final Thoughts: Automation Is Not a Side Quest
If we want to build high-quality software quickly and sustainably, test automation needs to be treated as a first-class citizen. That starts with making it part of the Definition of Done.
Not “we’ll automate later.”
Not “we’ll test it manually for now.”
But instead: “We’re done when we’ve built it, tested it, and proved it still works—automatically.”
📚 Further Reading & Resources:
-
How to Get Automation Included in Your Definition of Done – Angie Jones
A must-read for building a shared understanding of why and how automation fits into everyday development. -
Agile Testing: A Practical Guide for Testers and Agile Teams – Lisa Crispin & Janet Gregory
A foundational book covering modern testing mindsets, roles, and practices. -
The Testing Pyramid – Martin Fowler
A classic perspective on test layers, automation focus, and sustainable QA strategies.