Software testing cost: what QA adds to a development budget

The cost of software testing depends less on a tester's hourly rate than on how many user flows and platforms need checks, how much of the checking runs automatically, and whether the project needs a dedicated QA engineer. On the OddsCrowd web app, an app for sports bettors we built in 2018, the estimate gave QA 113 hours against 560 hours of backend and frontend work: 248 hours of backend and 312 of frontend. That estimate predates our work with AI agents; the next section explains what has changed since.
We do not sell testing as a separate service: it is part of how we build each feature, so it sits inside the project estimate.
Why software testing has no single price
Testing has no single price because, in a development project, it is a share of the work. Plan it as part of the scope in the estimate.
The QA line in an estimate is not all the testing on a project. On our projects, the tests developers write are part of each feature's price: our backend standard asks for a described test case with every change. Developers write those tests with the code using AI agents, and the pipeline runs them on every commit. When you compare two estimates, compare where testing appears in each, not only the size of the QA line.
For a sense of the whole budget, at Ronas IT a basic MVP starts from $5,000 with design and project management included, and a complex product, such as a marketplace or a SaaS, starts from $20,000. Developer tests, pipeline checks, reviews, and your check on a staging build, described in the next section, are part of how we build both.
What a testing budget pays for
A testing budget goes to checks at several points, from the developer's own tests to error reports after release. Each check catches a different kind of problem, so dropping one does not remove the bugs it would have caught. They move to a later check, and the last one is your users.

Here is the order in which a feature is checked on our projects:
- Tests are written before the code. With AI agents, the developer writes integration tests for the API and end-to-end tests that walk the user's path through the product, checks that they cover the scenario from the task, and only then has the code written until they pass. The tests do not call outside services for real, so a vendor that is down does not stop a release.
- The pipeline runs the tests on every commit. QA agents and an automatic AI code review check each commit as well. On the backend, the build step depends on the tests, so a version with a failing test cannot be deployed. On the frontend, a library with a critical known vulnerability stops the build.
- End-to-end tests check the main user actions on every build. They are written around what people do in the product, such as paying or sending a message, so a serious break shows up early.
- The developer hands the feature over with proof. They run the change in the development environment against the scenario from the task and attach a screenshot or a screen recording.
- Other people review it. A code review comes first, then a team lead review, then a manager review against the approved scope.
- You check it on a staging build. Staging is a copy of the product where you try a feature before your users get it.
- Errors in production are reported as they happen. Sentry, an error tracking service, shows the team what broke and where.
Because of this order, testing is not one final pass before launch. Its cost is spread over every sprint, and each sprint, usually one to three weeks long, ends with something you can open and check. Our guide to DevOps automation describes the pipeline side in more detail.
What makes testing cost more
Testing grows with the number of things that can break and with the price of each mistake. When you compare your product with the points below, you can tell whether the testing share of its estimate will be small or large.
- User roles and flows: a customer, a courier, and an admin each have their own paths through the product, and each path needs its own tests.
- Platforms: iOS, Android, and the web each need their own checks of the same feature, even when the apps share one codebase.
- Outside services: payments, maps, or a CRM. Tests replace each real service with a stand-in, and someone has to write that stand-in and keep it up to date.
- Forms and inputs: our field-level QA checklist goes past the expected path. It covers how a person gets to a screen, the default state of each control, keyboard and back-button behavior, window resizing, translated text, and harmful input typed into text fields.
- Money and identity: payments, sign-up, and identity checks need more test cases and often a dedicated QA engineer.
- AI features: a model can answer the same input differently, so a test that expects one exact output does not fit. OpenAI calls generative AI variable and recommends evaluations instead: a saved set of cases whose outputs are graded against criteria, which Anthropic's guide says can be done by code, by people, or by another model. The set runs again after every change to the model or the prompt, and each run is billed as model usage.
- How often you release: a manual check of the old features is paid again on every release, while an automated one is paid once and then kept up to date.
Manual or automated testing: which costs less?
Automated tests cost more to write and less to run, so they cost less for checks that repeat on every release. Manual checks cost less for new screens that still change often and for things you check only once. On our projects, every feature gets integration and end-to-end tests, and people check each new feature before it reaches you.
Automated tests also need upkeep: when a feature changes, its tests change too. That cost stays low when tests are tied to the steps a user takes, because those steps change less often than the way a screen looks.
AI agents change this math. When an agent writes a test and updates it after a change, and a developer reviews it, an automated check takes less effort to add and to keep current, so the point at which automating a check pays off moves earlier.
The tests also steer the agent. When an agent writes the code, we work test first: the developer and the agents set down the limits and the user flow as tests, see them fail, and only then let the agent write the code until they pass. A test written before the code comes from the task, not from what the code happens to do, so it catches a wrong guess of the agent instead of repeating it. The test-driven development skill for coding agents by Matt Pocock sets the same loop: one failing test, then only enough code to pass it, one slice at a time, with each test checking behavior through the public interface rather than the internal details.
That holds only while someone reads the test changes. Kent Beck, who built a B+ tree library mostly with an AI coding agent, lists the signs that made him stop the agent, and one of them is cheating, such as disabling or deleting tests. A review that skips the test files can miss a check that was switched off to make the build pass.
When a separate QA team is worth paying for
A dedicated QA engineer pays off when one missed bug costs more than that person's time. That is the case in payment and identity flows, especially in regulated products. On regulated products with payments or identity checks (KYC), a dedicated QA engineer is part of the team, and that role is included in the price: such regulated fintech and healthcare products start from $30,000. On other projects, we do not add a dedicated QA role by default.
“In a regulated payment flow, I want one person whose whole job is to break it before a user does. On a content screen, the developer's tests and our reviews are enough.”
Evgeny Leonov, CTO at Ronas IT

A separate QA team can also pay off when re-checking old features would stall new work. A team from outside should work to the standards of the company that builds the product. On one client project with no in-house QA people available, we brought in a subcontracted QA team and held it to ours: a set format for bug reports, defined rules for what gets checked, and required evidence from its testing. Our side checked the quality of its work. Developers kept building features while the QA team ran repeat tests of the existing product and checked how each new feature worked with the old ones.
What skipping testing costs
Skipped testing moves the cost of each missed bug to after launch. A bug that a test catches is fixed in the same task. A bug that a user finds adds a support conversation, a fix, a review, and a new release, and a mobile release also has to pass store review again. Some bugs also cost trust that no fix returns, such as a wrong charge on a customer's card.
For scale, in its 2022 report, the Consortium for Information and Software Quality estimated that the cost of poor software quality in the US had grown to at least $2.41 trillion.
Before the build starts, agree with the vendor on who pays for bugs found after launch. Our project managers record each reported bug as either warranty work or a new requirement.
How to lower testing costs without lowering quality
The savings come from testing the right things and keeping changes easy to check, not from fewer checks. Clear requirements also make testing cheaper, because a tester can only check what someone wrote down. Our guide on how to estimate a website or app shows how the scope turns into an estimate, QA included.
“I put the most tests where a bug costs money: payments, sign-up, and anything that sends data to another system. A small layout issue on a settings screen can wait for the next sprint. A wrong amount on an invoice cannot.”
Alexander Storozhevsky, Lead developer at Ronas IT
These habits help:
- Keep changes small: on our projects, one merge request covers one task or one part of it, and a reviewer may ask to split a large one. A bot flags changes that grow too large to review well.
- Make each bug fix leave a test: our backend standard treats a bug fix like any other change, so it comes with a test case. Before the fix, the developer reproduces the bug, by hand and in the automated tests if they exist, then removes the cause and walks the same steps again.
- Update libraries as routine work: in our frontend pipeline, a scheduled job opens merge requests for library updates, so each update gets a review instead of piling up into one risky upgrade.
- Agree on what “done” means before the build: our kickoff plan lists the stack, testing included, and the success criteria. The manager confirms the criteria with you, and the tech lead checks that they can be built.
Questions to ask a vendor about testing
Before you sign, ask each vendor these seven questions. They request specifics instead of a promise of quality, and the answers let you compare vendors on the same points.
- “Where is testing in your estimate?” A good answer shows where the testing work sits: in a QA line, inside each feature, or both.
- “What runs automatically on each change, and can a failed test stop a release?” The answer should be yes, and the team should explain how. A coverage percentage alone does not answer it: Kostis Kapelonis shows a one-line function with six unit tests and 100% coverage that still fails with a divide-by-zero error on one input.
- “Who checks a feature before I see it?” Expect names of roles, such as a code reviewer, a team lead, and a manager, not “the team”.
- “Will I get a staging build to check each feature?” If not, your users become the testers.
- “How do you handle bugs after launch?” Look for a clear rule that tells a bug in the agreed work from a new request.
- “When do you add a dedicated QA engineer?” A good answer ties it to risk, such as payments or identity checks.
- “Who writes your tests, and how is code from AI agents checked?” Agent-written code should go through the same tests and reviews as code written by a person, and a named engineer should accept it.
If you plan a first version of your product, our MVP development services cover the build, testing included.
What to do next
- List the flows in your product where a bug would cost money or trust.
- Decide which platforms the first release needs: web, iOS, Android, or a mix.
- Ask each vendor the seven questions above and compare the answers.
Frequently Asked Questions (FAQs)
How much does software testing cost?
It depends on who tests and how much of the testing is automated, so there is no single price. In a project built by a development team, testing is a share of the work in the estimate. For OddsCrowd, a web app for sports bettors that we built in 2018, before we started working with AI agents, QA got 113 of the estimated hours, next to 248 for the backend and 312 for the frontend. Today, on our projects, developers write the tests with each feature using AI agents and accept them, and the tests are part of that feature's price.
Is testing included in the price of software development?
It should be, and you should see where. At Ronas IT, testing is part of how each feature is built, so it is inside the project estimate and not sold as a separate service. A basic MVP starts from $5,000, and a complex product, such as a SaaS, from $20,000. Both prices include design, project management, and every testing layer: developer tests, pipeline checks, reviews, and a staging build you check yourself.
Why is a QA tester needed on a software development team?
A tester checks the product the way a user would and looks for the cases developers did not plan for. When developers write tests for each change and every feature passes several reviews, not every project needs a full-time QA engineer. A dedicated QA engineer pays off on payment and identity products, where one missed bug can cost money or break a rule.
What is the difference between quality assurance and quality control?
The ISTQB glossary defines quality assurance as activities that give confidence that quality requirements will be met, and quality control as activities that evaluate the quality of a component or system. In practice, quality assurance is how the team works (standards and rules for each change), and quality control is checking the result. Testing is one part of quality control.
How can you reduce software testing costs?
Spend the most testing effort on the flows where a bug costs money, such as payments and sign-up. Automate the checks that repeat on every release, keep each change small so a review can cover it, and make every bug fix leave a test behind, so the same bug is caught if it comes back.
Is automated testing cheaper than manual testing?
Over a product's life, usually yes for checks that repeat. An automated test costs more to write than one manual pass, but it then runs on every change without anyone repeating it by hand, while a manual check is paid again on every release. Manual checking stays cheaper for one-off checks and for new screens that are still changing often.
Why is quality assurance important in software development?
A bug caught by a test is fixed in the same task. One found by a user costs more: someone handles the support conversation, then come a fix, a review, and a new release, which on mobile also waits for store review. Quality assurance also keeps the code safe to change, so new features do not break old ones.
How are bugs found after launch handled?
That depends on the contract, so agree on it before the build starts. Ask the vendor how it tells a bug in the agreed work from a new request. On our projects, the project manager classifies each reported bug as warranty work or a new requirement.







