How to Start a QA Career in 2026: A Realistic Guide for First-Time Testers
Getting started in quality assurance in 2026 takes roughly four to nine months of focused study, one or two recognised certifications, and a small public portfolio that proves you can find bugs and write the kind of report a developer can act on. The market still has a wide front door — no CS degree required for most entry-level postings — but the work has shifted. A QA hire today is expected to know a little SQL, file a clean bug report, run a Playwright or Cypress test, and reason about risk, not just click through a script. This guide covers the role itself, the manual-versus-automation choice, the certifications worth their fee, the portfolio that gets interviews, realistic salary, and the trajectory beyond the first job.
Key takeaways
- QA is still one of the most accessible engineering tracks — most entry-level postings ask for a strong portfolio and certification rather than a CS degree, and a sizeable share of working testers entered from non-technical backgrounds.
- Manual-only is a shrinking lane. Glassdoor's April 2026 data places an entry-level QA tester at around $47,730 average, while an entry-level QA engineer (with automation skills) sits closer to $91,000. The skill gap, not the title, is the difference.
- ISTQB Foundation Level v4.0 (CTFL) is the certification worth getting first. Released 2023, it is vendor-neutral, recognised globally, and the exam costs around $199–$250 through ASTQB or BCS. It does not expire.
- The portfolio that gets interviews has three pieces — a documented exploratory test of a real public app, a handful of Playwright or Cypress specs on GitHub, and a clean bug report demonstrating reproduction steps, evidence, and environment.
- AI literacy now matters from day one. Testing AI features and reading AI-generated test code are real entry-level expectations in 2026, not specialist topics.
What a QA professional actually does day-to-day
A QA professional designs the verification strategy for a piece of software, runs it against the build, investigates anything that fails, and represents the user inside engineering. The title varies — Tester, QA Analyst, QA Engineer, SDET — but the work falls into the same four buckets.
Test design and execution. Writing test cases for new features. Running smoke tests on every deploy. Executing a regression suite against a release candidate. Practising exploratory testing where the formal cases are thin. Read an acceptance criterion, ask "what happens if a user does X instead?", and try X until something gives.
Bug investigation. Most QA time is not spent finding bugs — it is spent reproducing them, isolating them, and writing them up clearly enough that a developer can fix without three follow-up questions. A bad bug report wastes hours of engineering time per ticket. A good one closes the loop in one comment thread.
Automation engineering. Past the most junior level, you are expected to write code — Playwright or Cypress for web, Appium for mobile, Postman or Bruno for API testing, with JavaScript/TypeScript or Python tying it together. You are not building a backend; you are writing maintainable test code, debugging stack traces, and integrating tests into CI.
Quality advocacy. Sitting in sprint planning to flag acceptance criteria that cannot be tested. Reviewing a Figma prototype and asking what happens on a 320px screen. Watching production telemetry after a release and feeding incidents back into the next sprint. This is the shift toward embedded quality — and it now starts earlier in careers than it used to.
A practical example from a 12-person QA team at a Series B SaaS: in one week, a mid-level tester might write three Playwright specs for a new checkout step, triage two production incidents, run an exploratory session on a feature behind a flag, and pair with a developer to reproduce an issue only one customer had hit. None of that is "click through a script" — but none needs a CS degree either.
Manual vs automation: which path to start on
Manual or automation first? The honest 2026 answer is: you cannot skip manual, but you should not stop there.
Manual testing is the foundation. You cannot automate what you cannot test by hand. Before touching a framework, internalise the difference between smoke, sanity, regression, exploratory, integration, and acceptance testing — and the test-design techniques (equivalence partitioning, boundary value analysis, decision tables, state-transition testing) that let you cover real risk without writing 400 redundant cases. The ISTQB Foundation Level v4.0 syllabus covers this in 64 learning objectives and is free to download.
Automation is where the salary curve bends. The skill that separates the two pay bands is the ability to write a Playwright or Cypress spec, read a stack trace, fix a flaky test, and run the suite inside a GitHub Actions pipeline. You do not need to be a senior engineer — you need to modify existing test code without breaking it.
Here is how the two tracks compare in entry-level postings on LinkedIn in early 2026:
| Track | Typical title | Skills required | US salary band (entry) | Career ceiling |
|---|---|---|---|---|
| Manual-first | QA Tester, QA Analyst | Test design, bug reporting, basic SQL, Postman, manual regression | ~$45K–$65K | QA Lead, QA Manager — but harder to grow past mid-level without adding automation |
| Automation-leaning | QA Engineer (junior) | Above + JavaScript/Python, Playwright or Cypress, CI integration, Git | ~$70K–$95K | SDET, Senior QA Engineer, Quality Architect |
| SDET track | SDET / Test Engineer | Above + framework design, performance testing, contribution to product code | ~$90K–$115K | Staff Engineer in Test, Quality Architect, Engineering Manager |
Ranges aggregate Glassdoor and ZipRecruiter April 2026 data; expect 20–30% premium in major US tech hubs and a discount in lower cost-of-living markets.
The practical sequence: start with manual fundamentals (four to six weeks), then layer one scripting language and one framework on top. By month four you should be able to write a small Playwright test against a public site and explain why each assertion matters. That is the level interviewers screen for. The manual vs automated testing in 2026 post breaks down the trade-offs in more detail.
Certifications worth getting (and the ones that are not)
Certifications are a credibility signal, not a job ticket. The right one helps a recruiter put your CV on the interview pile when you have no prior experience. The wrong one is a sunk cost. Three are worth considering in 2026.
ISTQB Certified Tester Foundation Level v4.0 (CTFL)
The single most-cited certification in QA job postings worldwide. CTFL v4.0 was released in 2023 and is the only valid version — older syllabi have been retired. Fees vary by region and provider, typically $199–$250 through ASTQB in the US, around £165 through BCS in the UK, and the equivalent through iSQI internationally. The exam is 40 multiple-choice questions in 60 minutes, closed book, with a 65% pass mark. The certificate does not expire.
CTFL is most valuable in Europe, the UK, India, the Middle East, or any regulated industry (finance, healthcare, automotive, aerospace) — in those markets it is often a hard filter. In US tech-startup hiring it is closer to "nice to have" but still moves the needle. The ISTQB certification guide for 2026 has a deeper breakdown.
ISTQB Specialist certifications (CT-AI, CT-GenAI, CT-Mobile, CT-Performance)
Once CTFL is out of the way, the specialist tier becomes useful. The two worth flagging for 2026 are CT-AI v2.0 (released April 2026) and the newer CT-GenAI — both addressing how to test machine-learning and generative-AI features. Funded companies now budget against hallucinations, drift, and non-determinism as line items, and certified AI testers are still a thin market. Mobile and Performance specialist certifications are sensible later additions.
Vendor certifications and what to skip
Selenium, Playwright, Cypress, Postman, BrowserStack — most have their own learning paths or badges. Treat these as portfolio evidence rather than credentials; a finished Postman collection against GitHub's REST API, pushed to your profile, says more in an interview than any vendor certificate. Avoid the generic "software testing professional" courses on consumer learning platforms that bundle five tools into a weekend workshop — those hours are better spent on CTFL plus one framework deeply. CSTE and CSQA from QAI Global still appear on older enterprise postings — not wrong to hold, but a worse first dollar than ISTQB.
The foundational skills, in priority order
The order matters. Each skill is easier to learn once the one above it is in place.
Months 1–2: manual testing fundamentals and bug reporting. Read the ISTQB CTFL v4.0 syllabus. Practise writing test cases — pick a public app, take any feature's acceptance criteria, and write five positive and ten negative cases. Run a structured exploratory testing session and document the findings. Most importantly, learn to file a bug report a developer can act on — title, steps, expected vs actual, environment, console and network evidence, severity.
Months 2–3: SQL and HTTP/REST. Two skills that separate "manual tester" from "engineer who verifies state". SQL — SELECT, JOIN, WHERE, GROUP BY, basic indexing intuition — because almost every investigation eventually asks "did the database actually save this?" HTTP and REST — verbs, status codes, headers, auth patterns (Bearer tokens, cookies, CORS) — because the UI and API often disagree, and the API is the source of truth.
Months 3–4: one API client and one scripting language. Postman remains the default; Bruno and Insomnia are fine alternatives but appear less often in postings. Pick JavaScript/TypeScript or Python and go deep enough to write functions, read someone else's code without re-architecting it, and use a debugger rather than console.log.
Months 4–6: one automation framework. Choose based on language. JavaScript/TypeScript opens Playwright and Cypress; Python opens Selenium with pytest, or Playwright's Python bindings. Playwright has the most momentum entering 2026 — its developer satisfaction score in the State of JS 2025 survey was the widest gap over Cypress on record, and npm downloads cleared 30 million weekly in early 2026. The Selenium vs Playwright vs Cypress 2026 comparison goes deeper.
Months 5–7: CI and Git. Learn enough Git to branch, commit, push, open a PR, and resolve a merge conflict — and enough GitHub Actions or GitLab CI to run your suite on every push. Most self-taught QA candidates stall here, and it is the step that gets the first phone screen.
Months 6–9: accessibility and AI basics. Accessibility-as-CI is mainstream — running Axe, Pa11y, or Lighthouse against PRs and failing the build on violations is normal. Learn WCAG 2.2 at AA level and the European Accessibility Act timeline (enforcement began June 28, 2025). For AI features, learn what hallucination, drift, and non-determinism mean in a testing context.
Your first portfolio: what to actually build
A portfolio is the single highest-leverage thing an aspiring QA can build, and it almost always beats one more certification when competing for the first interview. Three artefacts, all on a public GitHub profile, are enough.
1. A documented exploratory testing session
Pick any public web app — a personal finance tool, a free-tier SaaS, an open-source project. Run a two-hour structured exploratory session. Document the charter, areas in scope, bugs found, and questions raised — one markdown file in a repo, plus screenshots and short screen recordings. This shows you can think about risk, not just execute scripts.
2. A small Playwright or Cypress test suite
Same target app, or a deliberately buggy training site (Sauce Demo, OrangeHRM, Restful-Booker). Ten to twenty Playwright or Cypress specs covering a critical journey — login, search, add to cart, checkout — with at least one negative-path test and one API-level test alongside the UI. Wire it to run on push via GitHub Actions. A suite green in CI beats fifty cases that only ran locally.
3. A bug report a developer would not need to clarify
One detailed, well-evidenced bug — pinned in a bugs/ folder as a markdown file. Title, environment, steps, expected vs actual, severity, priority, screenshot, console error, network trace. This is the artefact most candidates skip and most hiring managers actually read. The cleanest reports tell a story with evidence — whether filed manually or generated by a tool like Crosscheck.
A bonus fourth for automation-leaning candidates: a Postman or Bruno collection against a real public API (GitHub REST, PokeAPI, JSONPlaceholder) with environment variables, test assertions, and a Newman CLI runner. Recruiters skim repos; have the README explain in one paragraph what each project demonstrates.
Breaking into QA without a computer science degree
The most common career-change route into software testing is from an adjacent role rather than a CS degree — and hiring managers know it.
Customer support and customer success transition cleanly — both require user empathy, attention to detail, and the pattern recognition that turns scattered complaints into reproducible bugs. The translation step is learning the engineering vocabulary: "weird thing on the dashboard" becomes "intermittent 502 from /api/dashboard on cold cache". Many support engineers move sideways into QA within six months of deliberate study.
Business analyst, data analyst, and project manager backgrounds also map well — each already involves requirements analysis, documentation, and stakeholder communication, so adding test design and automation tends to be faster than starting from zero. Non-software backgrounds — finance, healthcare, education, manufacturing QA — also work, particularly in regulated industries where domain knowledge is valuable. A nurse who can read EHR workflows or a financial controller who understands T+2 settlement is more useful on a healthcare or fintech QA team than a generalist with no domain context.
For any of these paths, the formula is roughly the same: four to nine months of structured self-study, the ISTQB CTFL exam, a public portfolio of three to five repos, and a focused job-search push at companies whose domain you already understand. The first job is the hardest; the second moves faster.
Salary expectations: a verified 2026 picture
Glassdoor's April 2026 data, cross-checked against ZipRecruiter and Levels.fyi, paints a clearer picture than the wide ranges most career guides cite. US averages — adjust upward 20–30% for high cost-of-living hubs (Bay Area, NYC, Seattle), downward elsewhere.
| Role | Entry-level | Mid-level | Senior |
|---|---|---|---|
| QA Tester (manual-leaning) | ~$45K–$65K | ~$65K–$85K | ~$80K–$100K |
| QA Analyst | ~$50K–$80K | ~$80K–$105K | ~$95K–$120K |
| QA Engineer (automation) | ~$70K–$95K | ~$95K–$130K | ~$120K–$160K |
| SDET | ~$90K–$115K | ~$120K–$150K | ~$150K–$200K |
| QA Lead / Manager | — | ~$110K–$140K | ~$140K–$185K |
Sources: Glassdoor April 2026, cross-checked against ZipRecruiter. FAANG and equivalent total comp regularly clears $200K once equity is included, per Levels.fyi 2026 data. The QA engineer salary guide for 2026 ladders these figures against years of experience and location.
Two patterns worth noting. The manual-to-automation jump is the steepest single salary movement in the QA career — typically $25K–$40K once you can credibly own a Playwright or Cypress suite. The SDET band has compressed against Software Engineer pay in the last two years, especially where the same person ships product code and test infrastructure.
The career trajectory beyond the first job
QA is not flat. After two or three years it branches roughly four ways.
Engineering track — QA Engineer to Senior QA Engineer to SDET to Staff Engineer in Test. Deeper into automation, framework design, performance testing, and contributing to product code. The ceiling mirrors senior backend engineering compensation.
Management track — QA Engineer to QA Lead to QA Manager to Director of Quality to VP of Quality. Less code, more people, more business framing. Smaller pool of roles at the top, but pays well at director and above, especially in regulated industries.
Specialist track — performance engineering, accessibility engineering, security testing, AI/ML quality. Each branches into adjacent disciplines that often pay above the general QA average and face less competition. Accessibility specialists are in particular demand following the European Accessibility Act enforcement that began June 2025.
Lateral track — many move into product management, developer relations, technical writing, UX research, or full-stack engineering. The transferable skill is the same: a deep understanding of how software actually behaves, and the ability to communicate it.
The first job sets the trajectory less than people fear. A first-year QA analyst at a small SaaS can rebrand into a QA engineer at a larger company eighteen months later, given the right portfolio and one or two automation projects shipped. Job-to-job moves in years two through five usually carry larger raises than in-role ones — staying technical and shipping public work matters more than the title on the first business card.
FAQ
How long does it take to become a QA tester from scratch?
Four to nine months of focused study is realistic for the first manual-leaning role, and six to twelve months for a junior automation role. The variance comes from prior experience — anyone with software, support, or analytical background tends to land on the shorter end of that range.
Do I need a degree to get into quality assurance?
No. Most US and UK entry-level QA postings in 2026 list a degree as "preferred" rather than "required", and a strong portfolio plus ISTQB CTFL routinely beats a generic CS degree with no projects. Regulated industries (aerospace, medical devices, automotive) are the most likely to enforce a degree requirement.
Should I start with manual or automation?
Start with manual fundamentals for four to six weeks before layering automation. You cannot automate what you cannot test by hand, and the test-design vocabulary carries directly into writing readable automated tests. The mistake is stopping at manual.
Is QA being replaced by AI in 2026?
No, but the role is being rewritten. AI is automating test-script generation, failure triage, and synthetic data creation. The judgment-heavy parts — exploratory testing, risk reasoning, quality advocacy, testing AI features themselves — are growing rather than shrinking. Manual-only roles with no AI literacy are the most exposed.
What is the difference between QA Tester, QA Analyst, QA Engineer, and SDET?
Tester and QA Analyst sit at entry-level, focused on test execution, design, and reporting — usually manual-leaning. QA Engineer adds automation, CI integration, and code ownership. SDET sits closest to a software engineer, building test frameworks and often shipping product code. Pay follows that order, with the largest jump between Analyst and Engineer.
Start filing better bug reports today
The highest-leverage habit a new QA can build in the first month on the job is filing bug reports developers actually want to receive — clean reproduction steps, console and network evidence attached, the right environment captured automatically. That habit builds the reputation for taking friction out of the engineering loop, which is what compounds into faster promotions.
Crosscheck is a free Chrome extension built for that part of the workflow. It captures screenshots, screen recordings, console logs, and network requests in a single click, then sends the report straight to Jira, Linear, ClickUp, GitHub, or Slack — so the report is complete on the first send and the back-and-forth disappears. No paid tier, no usage limits.
