Every QA budget conversation hits the same question. Selenium, Appium and Playwright cost nothing to download, so why pay for a platform? And if a platform costs $20 or $199 a month, why pay engineers to write scripts?
Both sides argue from the sticker price, which is the smallest number in the calculation.
Writing Selenium or Appium tests in-house tends to be cheaper when your UI is stable, your test surface is small and you already employ strong automation engineers. For most teams the real cost is engineer time spent on maintenance, flaky-test triage and infrastructure, not licences. Put your own numbers into the model below to see which side wins for you.
This guide gives you a cost model you fill in yourself, the hidden costs on both sides, an honest list of cases where in-house wins, and the real price tiers for Robonito.
Key takeaways
- Open-source frameworks have no licence fee, but you pay for authoring, maintenance, triage, CI minutes and browser or device infrastructure.
- Maintenance after UI changes is usually the term that grows fastest. Measure it before you compare tools.
- Platforms swap some engineer hours for a subscription, a learning curve and some lock-in. Code export reduces the lock-in.
- In-house Playwright or Selenium can genuinely be cheaper for small, stable products with a strong SDET team.
What does it cost to write Selenium or Appium tests in-house?
The frameworks themselves are free. Selenium, Appium and Playwright are all open source under the Apache-2.0 licence. So "Selenium automation framework pricing" is really a question about everything around the framework:
- People: the engineers who design, write, review and fix tests.
- Infrastructure: CI runners, a browser grid, and phones or a paid device cloud for Appium.
- Time to competence: onboarding new engineers into the framework, page objects and conventions your team has built.
None of those appear on a pricing page.
The cost model: fill in your own numbers
Use the same structure for both options so you're comparing like with like. Each variable is something you can measure from your own sprint data, timesheets or CI bills.
| Variable | In-house (Selenium / Appium / Playwright) | AI-native platform |
|---|---|---|
| R | Engineer hourly cost, fully loaded | Same |
| N | Number of tests | Same |
| Authoring | W = hours to write one test | A = hours to author one test in the platform |
| Review | Included in W (code review) | V = hours to review one generated test |
| U | UI changes per month that affect tests | Same |
| Fix per change | F = hours to fix tests per UI change | Fp = hours to review healed steps and fix what didn't heal, per UI change |
| Triage | T = flaky-failure triage hours per month | Tp = triage hours per month |
| Infrastructure | I = CI plus browser grid or device cost per month | Ip = any CI cost you still pay to trigger runs |
| Subscription | None | P = plan price per month |
| Onboarding | O = onboarding hours per year | Op = hours to learn the tool, per year |
The formulas:
- In-house year one = R × (N × W + O) + 12 × [R × (U × F + T) + I]
- Platform year one = R × (N × (A + V) + Op) + 12 × [P + R × (U × Fp + Tp) + Ip]
The first bracket is the build cost. The second is what you pay every month to keep the suite alive.
The model leaves out escaped defects and releases delayed by a red build nobody trusts. Both are real but hard to price, so weigh them as a judgement call.
Worked example A: a mid-sized web and mobile suite
Example inputs: replace with your own. These are hypothetical placeholders, not benchmarks or Robonito results.
| Input | In-house | Platform |
|---|---|---|
| R (hourly cost) | $60 | $60 |
| N (tests) | 100 | 100 |
| W, or A + V (hours per test) | 3 | 0.5 + 0.25 = 0.75 |
| O or Op (onboarding hours per year) | 40 | 8 |
| U (UI changes per month) | 4 | 4 |
| F or Fp (hours per UI change) | 6 | 1 |
| T or Tp (triage hours per month) | 10 | 4 |
| I or Ip (infrastructure per month) | $300 | $0 |
| P (plan per month) | none | $199 (Pro, needed for mobile) |
The arithmetic:
- In-house build: $60 × (100 × 3 + 40) = $60 × 340 = $20,400
- In-house monthly: $60 × (4 × 6 + 10) + $300 = $2,040 + $300 = $2,340
- In-house year one: $20,400 + 12 × $2,340 = $20,400 + $28,080 = $48,480
- Platform build: $60 × (100 × 0.75 + 8) = $60 × 83 = $4,980
- Platform monthly: $199 + $60 × (4 × 1 + 4) = $199 + $480 = $679
- Platform year one: $4,980 + 12 × $679 = $4,980 + $8,148 = $13,128
Be careful with the platform column. A, V, Fp and Tp are the inputs you know least about before you try a tool, and they decide the result. Run a pilot on 10 to 20 of your real tests and time them before you trust any comparison, including this one.
Worked example B: a small, stable web app
Example inputs: replace with your own. Here the team already knows its framework, the product changes rarely and CI fits a free tier.
- R = $60, N = 20, W = 1, O = 0, U = 0.5, F = 2, T = 2, I = $0
- Platform: A + V = 0.75, Op = 8, Fp = 1, Tp = 2, Ip = $0, P = $20 (Starter, needed for CI/CD)
The arithmetic:
- In-house year one: $60 × 20 + 12 × [$60 × (0.5 × 2 + 2)] = $1,200 + 12 × $180 = $3,360
- Platform year one: $60 × (20 × 0.75 + 8) + 12 × [$20 + $60 × (0.5 × 1 + 2)] = $1,380 + 12 × $170 = $3,420
That's effectively a tie, with in-house slightly cheaper. At this size, cost shouldn't decide it. Skills, ownership and how you want to review tests should.
What are the hidden costs of in-house frameworks?
Maintenance after UI changes
Every renamed button, moved field or new modal can break locators across dozens of tests. In the model this is U × F, and it repeats every month the product changes. Our guide to self-healing test automation explains why locator breakage dominates.
Flaky tests
A test that fails one run in twenty still costs an investigation every time. Timing issues, shared test data and slow environments all add triage hours (T), and a flaky suite trains people to re-run red builds instead of reading them.
Grid and device infrastructure
Selenium Grid and Appium servers need machines, browsers, drivers and upgrades. If you rent instead, cloud grids charge by product, plan, team size and the number of parallel sessions. Check BrowserStack's pricing page for current Automate prices, and price the parallel sessions your suite actually needs, since more sessions cost more.
Specialist skills for Appium
Mobile automation needs people who understand Appium drivers, Android and iOS build tooling, signing and platform-specific locators. Those skills are scarcer than web scripting and hard to cover during holidays.
Knowledge loss when the author leaves
A framework built by one engineer carries their conventions: custom waits, helpers, page objects and workarounds. When they leave, the next person has to learn it all before they're productive. That's the O term, and it recurs with every new joiner.
CI minutes
Every run burns runner time. GitHub's runner pricing lists a standard 2-core Linux runner at $0.006 a minute and a macOS runner at $0.062 a minute. A 30-minute suite costs 30 × $0.006 = $0.18 on Linux, or 30 × $0.062 = $1.86 on macOS, per run. Multiply by runs per day, parallel shards and working days, and iOS builds in particular add up.
What are the hidden costs of an AI testing platform?
The subscription
Check the limits as well as the price. Most platforms cap test cases, execution minutes or parallel runs per tier, so growth steps the price up.
Lock-in, and how code export reduces it
If your tests exist only inside a vendor's platform, leaving means rebuilding them. Ask any vendor what you can take with you. Robonito can generate executable code for your test cases, which gives you a starting point if you ever move back to a code framework. Check what the export covers for your own tests during a pilot.
Learning a new tool
Even a plain-language tool has conventions: how to structure journeys, reuse steps, manage test data and read results. Budget the Op hours honestly.
Limits on what can be expressed
Heavy custom logic, unusual assertions or deep integration with your own code can be harder to express without code. Look for low-code extensions, and pilot your hardest scenario, not your easiest.
Data and security review
A platform touches your application, test data and sometimes credentials. Expect a security questionnaire and a vendor review, which can take a while in regulated companies.
When is in-house Playwright or Selenium cheaper?
Sometimes it is, and pretending otherwise doesn't help you. In-house tends to win when several of these are true:
- You have a strong SDET team who write tests quickly and already maintain a clean framework.
- Your UI is stable. If U is close to zero, the maintenance term is small and a platform's biggest advantage shrinks.
- The surface is small. A few dozen web tests don't justify new tooling.
- You have heavy custom logic that's easiest to express in code, such as complex data setup, custom protocols or calls into internal libraries.
- Everything must go through code review. If every test must live in the repository beside the application code, a code framework fits natively.
- You only test web. Playwright covers modern browsers well, and you avoid the Appium specialist cost entirely.
If that describes you, keep your framework and spend the effort on test design. Our Robonito vs Playwright page sets out where each one fits, and the 2026 QA automation tool comparison covers the wider market.
The model tips the other way when the UI changes every sprint, when you need mobile, desktop and API coverage, when the people who know what to test don't write code, or when one engineer owns the whole framework. The Robonito vs Selenium page compares the two approaches feature by feature.
Where Robonito fits, and where it doesn't
Robonito is an agentic QA platform: AI agents create, run and maintain end-to-end tests. In the cost model, it aims at three terms.
- Authoring (A + V): describe a test in plain language, paste a URL or reference a Jira issue, and the agent works through the app step by step. AI Studio can also generate tests from requirement documents, Swagger/OpenAPI definitions and the live app. You review the result.
- Maintenance (U × Fp): self-healing adapts steps when labels, layouts or locators change, and logs healed steps for you to review.
- Triage (Tp): every run keeps video, network traces and an AI root cause for failures, so investigating a red build starts with evidence.
On infrastructure, tests run in parallel in isolated cloud workers. For security reviews, Robonito has a SOC 2 Type II report (shared under NDA), role-based access, audit logs, and cloud, private cloud, on-premise or hybrid deployment.
Where it fits less well: if your team already maintains a fast, stable code suite and wants every test in pull requests, the switching cost may not pay back. Run the model first.
Club Car moved its CPQ and 3D configurator testing to Robonito and cut QA testing time by over 70%. Your numbers will differ, which is why the pilot matters. and bring five of your real journeys, or and time your first test yourself.
What are the pricing tiers for AI-powered QA automation at Robonito?
These are Robonito's list prices. The pricing page has the full feature list.
| Plan | Price | What you get |
|---|---|---|
| Free | $0, free forever | 100 test cases a month, 60 execution minutes, web testing, plain text to test case & Autopilot, self-healing |
| Starter | $20/month ($16/month billed annually) | 300 test cases a month, 180 execution minutes, CI/CD integration, Jira & Slack |
| Pro | $199/month ($159.20/month billed annually) | 1,000 test cases a month, 30 hours of execution, 5 parallel runs, adds mobile, desktop and API testing |
| Custom | Contact sales | Unlimited test cases, custom parallel runs, every platform, custom SLA |
CI/CD integration (Jenkins, GitHub Actions, GitLab CI and Azure DevOps) needs Starter or above. If you're comparing against an in-house Appium suite, Pro is the first tier with mobile testing. Use the plan price as P in the model, and check the monthly test-case and execution limits against your own volume.
Frequently asked questions
Is it cheaper to have engineers write Selenium or Appium tests or to use an AI-native platform?
It depends on your inputs. In-house is often cheaper for small, stable products with a strong automation team. A platform is often cheaper when the UI changes frequently, you need mobile or API coverage, or maintenance and triage eat your engineers' time. Fill in the model with your own numbers.
Are Selenium and Appium really free?
The software is. Selenium, Appium and Playwright are open source under Apache-2.0. You still pay for the engineers who write and maintain tests, CI runner minutes, and browser grid or device infrastructure.
What's the biggest hidden cost of in-house test automation?
For most teams it's maintenance after UI changes, followed by flaky-test triage. Both recur every month, unlike the one-off cost of writing tests.
How do I avoid lock-in with a testing platform?
Ask what you can export before you commit. Robonito can generate executable code for test cases. Also keep your test intent (journeys, data and acceptance criteria) documented outside any single tool.
How should I run a fair cost comparison?
Pick 10 to 20 real tests, including your hardest ones. Time how long they take to write, review and fix after a UI change in both approaches. Use those measured hours, not vendor or blog estimates, in the formula.
Which Robonito plan do I need to replace an Appium suite?
Mobile app testing for Android and iOS is on Pro ($199/month, or $159.20/month billed annually) and Custom. Free and Starter cover web testing only.
Get your own numbers, not ours: automate a real journey and time it against your framework. or see pricing.
