Notes on quality, and what we ship
Product updates, the thinking behind them, and field notes on quality engineering from the team building Tesbo.
All articles
Linking Test Cases to Jira Issues So the Link Survives the Sprint
Pasting an issue key into a text field feels like linking. It rots the moment a story splits or closes. Here is the link that actually survives.
Source Available vs Open Source: The Three Questions That Settle It
A GitHub link is not proof of open source. Here are the three questions that separate open source from source available in about five minutes.
An Open Source QA Stack for a Team of Six: The Joins Nobody Writes Down
A worked open source QA stack for a six person team: what the four jobs are, where they connect, and what actually breaks.
Test Case Versioning: What Changed, When, and Who Agreed to It
A test case that passed in March and fails in June raises one question: did the product change or did the case? Versioning is how you answer it.
Positive and Negative Testing: The Cases That Actually Find Bugs
Positive cases prove a feature was built. Negative cases prove it was built carefully. Here is how to write both, with a payments example.
System Integration Testing: And Whose Bug It Is
SIT is the phase where nobody is sure whose bug it is. How a documented contract case settles ownership, and why the environment is the real blocker.
GxP Test Documentation, in Plain Terms
"GxP" turns "we tested it" into "show the controlled, traceable evidence." The testing isn't the hard part — the shape of the documentation is.
Test Evidence for a 21 CFR Part 11 Audit
21 CFR Part 11 doesn't ask whether you tested. It asks for attributable, time-stamped, signed records that show what you tested — and that a person approved it.
End-to-End Testing: What It Proves That Nothing Else Does
End-to-end testing proves one thing no other layer can, and costs more than any other layer to keep. How to choose the few journeys worth it.
Test Management Tools: 15 Options, Grouped by Team Fit
Fifteen test management tools grouped by the kind of team each one fits, with the honest tradeoff of every group and a two-week way to actually decide.
Gray Box Testing: Why Most Real Testing Is This
Gray box testing is taught as an exotic third option. It is actually what almost every tester does, and partial knowledge cuts both ways.
Black Box vs White Box Testing: Two Different Case Sets
Run one feature through both and they produce genuinely different cases. Which set survives a refactor, and which one an auditor can actually read.
Component Testing: The Layer Between Unit and Integration
Unit, component and integration are separated by one decision: what gets mocked. Where to put the boundary, and what a component test case contains.
Traceability for Medical-Device Software (ISO 13485)
For medical-device software, traceability isn't a nicety. A design input has to link to the test that verifies it — and an auditor follows that thread.
Test Evidence for an Audit: Proving Testing Happened
An audit doesn't ask whether you tested. It asks you to prove it — with a chain from requirement to case to run to defect, and a named person who signed off.
Sanity Testing: When It Is Genuinely Different From Smoke
Most teams run one check and call it two. Here is the single condition where sanity testing earns a separate name, and what the cases look like.
API Testing: A Complete Guide to Cases, Types and Tools
What API testing proves, the four types worth keeping separate, the six parts of a real case, and how a written case connects to the test that runs it.
What Is a Bug? The Real History of the Word
The word predates software by seventy years, and the famous moth story is not the origin. Here is the honest history, and why it changes how you write tickets.
Defect Leakage: The QA Metric Measured Against Reality
Coverage measures you against your own test suite. Defect leakage measures you against reality: of the bugs that existed, how many did you catch first?
Exploratory Testing That Leaves a Record
Exploratory testing isn't just poking around. Its output is findings — and a finding nobody writes down as a case evaporates when the session ends.
Smoke Testing: The Check That Decides Whether Testing Starts
Smoke testing is a gate, not a test type. What belongs in the suite, how long it may take, and the twelve cases written out in full.
Test Scenario vs Test Case: Which One a Risk Needs
A scenario says what to verify, a case says how. Here is what each costs, how they differ point by point, and a two-question test for choosing fast.
Mobile App Testing: Types, Checklist and Tools
Mobile fails in ways the web cannot: interrupts, networks, fragmentation and store review. The types, a release checklist, and how to pick a device matrix.
Software Testing in 2026: The Trends That Are Real
One change is driving every QA trend worth naming. What is genuinely in production, what is still a demo, and how the job itself is shifting.
The Best AI Testing Tools Depend on the Job You Have
The phrase hides three different products. Which job you are hiring for, the benefit and caveat of each, and the questions that make a demo useful.
Self Hosted vs Cloud Test Management: How to Decide
Compare self-hosted and cloud test management by control, total cost, operational ownership, and your ability to change deployment later.
Smoke vs Sanity vs Regression Testing: Three Words, One Confusion
Used interchangeably in most standups. Compared on scope, trigger, owner, runtime and what a failure blocks, with one real change run through all three.
Self-Hosted Test Case Management: What You Actually Take On
Open source is a licence question. Self-hosting is an operations question. Here is the real bill: backups, upgrades, Postgres, and who gets paged.
Free Test Management Platform: Where Free Runs Out
Every result for this search is a list of ten tools. None of them tell you the thing that decides it: what your free tier is designed to run out of.
Flaky Tests Are a Design Problem, Not Bad Luck
A flaky test isn't bad luck. It assumed something about timing, state, or isolation the system never guaranteed. A retry hides that — it doesn't fix it.
Test Automation Strategy: Three Questions, Not a Tool
Most test automation strategies are a tool pick in disguise. A real one answers three questions: what earns automation, who maintains it, and what gets deleted.
Audit Trail in Test Management: The Approval Log
A test case marked "reviewed" is an assertion. The same case with a name, a date, and what changed before it was accepted is evidence. That's the approval log.
Negative Test Cases for APIs: The Ones That Find Bugs
A happy-path API suite passes until a real client sends something weird. The bugs live in the negative cases: bad auth, malformed bodies, and edge states.
The Complete Guide to Software Testing Strategies, Types & Tools
Strategy first, tools last. How to decide what to test and where, the types of testing that matter, and the tool categories QA teams actually need.
AI in Software Testing: What Actually Works
AI in software testing was sold twice and delivered once. Sort the claims into three piles by one test: does a person still accept the output?
When Not to Automate a Test (and What to Do Instead)
Automation has a running cost nobody bills you for. For run-once, fast-changing, and judgement-heavy tests, upkeep costs more than the manual run it replaced.
API Test Cases: What a Real One Contains
Most API "tests" check that you got a 200 OK. A real API test case names the endpoint, the request, the preconditions, and one exact response — body and status.
Test Management Tool Migration Plan: Keep the History
Migrations stall in the middle, not on the export. Run history and attachments don't survive a CSV — so decide what you'll lose before you export anything.
Bring Your Own API Key: AI Tools and Your Data
A security review of an AI tool asks four things: whose model, whose key, whose data, and what leaves the network. Bring-your-own-key answers most of them.
Will AI Replace QA Engineers? The Honest Answer
Will AI replace QA engineers? No. But the part of the job that was always typing is going — and the part that was always judgement is about to matter more.
How to Document Exploratory Testing (Without the Bloat)
The point of documenting exploratory testing isn't a report nobody reads. It's making sure the bug you found — and the case you should keep — don't vanish.
Session-Based Test Management, Explained
Exploratory testing a lead can trust needs structure, not a script. Session-based test management gives it three things: a charter, a timebox, and notes.
%2520%2520Tesbo-900x600.png%3Fprefix%3Dprod&w=3840&q=75)
QA Metrics: The Four Worth Reporting (and Why)
Every list of twenty QA metrics is eighteen you'll stop updating by March. Here are the four that survive one test: what decision changes when the number moves?
Flaky Test Detection: Finding Them in Your Run History
A flaky test passes and fails on the same code. You can't see it in one run — you find it in your run history. Here's how to measure flakiness precisely.
AI Test Case Generation: Generate Freely, Merge Carefully
AI writes test cases fast — including confident ones that are wrong. The fix isn't a better prompt. It's a review queue where a person approves each case.
-1-900x600.png%3Fprefix%3Dprod&w=3840&q=75)
What to Automate First in Testing: A Scoring Method
Stop deciding what to automate by whoever's loudest. Score each test on frequency, escape cost, stability, and cost — then automate down the ranked list.
-1-900x600.png%3Fprefix%3Dprod&w=3840&q=75)
Open-Source Test Case Management: What Actually Matters
"Open source" can mean four very different things. What matters is simpler: can you run the whole tool yourself, and does your data stay private?
-1-900x600.png%3Fprefix%3Dprod&w=3840&q=75)
Test Case Management: The Record a Release Rests On
Test case management isn't documentation overhead. It's the record that lets you say what you covered, what changed, and why a release shipped.
Every release, in plain language
What shipped, what changed, and why we chose it. No version notes written for machines.
See tested, untested, and risky areas per suite, with run history behind every number.
Zyra turns a failure into a structured report with logs and steps, queued for your approval.
Bring an existing repository across with suites, priorities, and owners intact.
Every AI draft carries who approved it, when, and what changed before it entered the suite.
One page, one idea
-1-900x600.png%3Fprefix%3Dprod&w=3840&q=75)
-1-900x600.png%3Fprefix%3Dprod&w=3840&q=75)
Start here if you are new to Tesbo
Four short guides that take you from an empty project to a reviewed suite and a first run.
One email a month. Releases and one good idea.
What we shipped, what we learned, and the occasional infographic worth pinning. Unsubscribe in one click.