Most QA engineers who stall at mid-level are doing excellent work, just entirely for themselves. The jump to senior requires shifting from executing tasks to owning outcomes: catching systemic issues before they're raised, helping others improve, and shaping how quality works on the team. This article covers what's actually expected at each level, the behaviors that drive promotion rather than time served, and the fork between the individual contributor and management tracks.
The Core Levels
Most companies structure QA roles across three to four bands:
| Level | Typical titles | Years (rough) |
|-------|---------------|---------------|
| Junior | QA Engineer I, Junior QA Tester | 0–2 years |
| Mid-level | QA Engineer, QA Engineer II | 2–5 years |
| Senior | Senior QA Engineer | 5+ years |
| Staff/Lead | QA Lead, Staff QA Engineer, QA Manager | 8+ years |
Years are a rough indicator, not a gate. Some engineers reach senior in 3 years; others take 8. The delta is almost always in how intentionally they've grown, not time served.
Junior QA Engineer (0–2 years)
What you're doing
- Executing test cases written by others
- Reporting bugs using established templates
- Learning the product and its user flows
- Getting comfortable with the team's tools (Jira, Playwright/Selenium basics, Postman)
- Running existing regression suites and reporting results
- Asking questions frequently — this is expected and encouraged
What the company expects
That you follow direction, learn quickly, catch obvious bugs, and ask for help when blocked rather than guessing. You're not expected to design test strategy. You're expected to execute what's in front of you and grow.
What actually moves you to mid-level
Not time. These behaviors:
- You proactively explore beyond the documented test cases
- You find bugs that aren't in the test plan
- You ask "should I also test X?" and usually the answer is yes, you're right to ask
- You start contributing test case ideas, not just executing them
- You become reliable — people trust your "pass" result is real
Common junior mistakes to avoid
- Testing only the happy path and calling it done
- Filing bugs without steps to reproduce
- Waiting to be told what to test next instead of identifying the next task
- Not asking for clarification on vague requirements
Mid-Level QA Engineer (2–5 years)
What you're doing
- Writing test cases from scratch, from user stories and AC
- Owning a feature area's test coverage — you know what's covered and what's not
- Contributing to automation — writing new Playwright tests, maintaining existing ones
- Triaging bugs (severity, priority, can I reproduce this?)
- Starting to onboard and mentor juniors on the team
- Participating actively in sprint ceremonies — your input in planning matters
What the company expects
Independence. They give you a feature, and you figure out how to test it. You still escalate blockers, but you're not waiting for step-by-step direction. You understand the product well enough to identify testing gaps without being told.
What actually moves you to senior
Not writing more tests. These shifts:
From execution to ownership. You don't just test features — you own the quality of a product area. You notice when something's getting fragile and raise it before it becomes a problem. From testing to contributing to strategy. You start asking "why are we testing this this way?" and suggesting better approaches. Your test plan influences what gets built. From doing to enabling. You help juniors improve. You write documentation that makes the team more effective. You identify process bottlenecks. From reactive to proactive. You catch issues before they reach testing — in requirements reviews, in design discussions, before the code is written.Senior QA Engineer (5+ years)
What you're doing
- Defining testing strategy for new features and major releases
- Making decisions about what to automate vs. what to test manually
- Owning the automation framework — setting standards, reviewing others' code
- Driving quality across the team, not just in your own work
- Mentoring mid-level and junior engineers
- Partnering with PMs and engineering leads on quality risks
- Identifying systemic quality problems and proposing solutions
What the company expects
Senior QA is a multiplier. Your impact should be bigger than what one person can do. If you're only making yourself more productive, you're doing mid-level work with a senior title.
Seniors define how quality works on the team. They create the playbooks, establish the standards, and shape the culture around testing. When something is unclear, others look to them.
What distinguishes senior from mid-level in practice
| Situation | Mid-level response | Senior response |
|-----------|-------------------|----------------|
| Ambiguous requirements | Asks for clarification | Calls a 15-min sync, resolves it, documents the decision |
| Flaky test in CI | Fixes the test | Fixes the test + investigates why + adds retry logic + proposes improvement to prevent future flakiness |
| New team member | Answers questions | Creates onboarding doc, pairs for first sprint, provides structured feedback |
| Production incident | Helps investigate | Runs retrospective, creates prevention plan, adds monitoring |
| Sprint velocity issue | Mentions it in standup | Identifies root cause, proposes solution, tracks improvement over 2 sprints |
Skills That Accelerate Progression at Every Level
Technical skills (hard to skip)
Test automation: You need to be able to write and maintain Playwright (or equivalent) tests. Not optional past junior level. API testing: Understanding and testing REST APIs. Reading network traffic. Writing API-level tests. CI/CD basics: Knowing how tests run in pipelines, being able to debug CI failures. SQL: Basic queries to verify data in databases.SELECT, JOIN, WHERE. Comes up constantly.
Git: Proper branching, PRs, resolving conflicts. Your automation lives in code, code lives in git.
Non-technical skills (underestimated)
Communication: Writing clear bug reports. Explaining risk to non-technical stakeholders. Raising concerns without being alarmist. This is what separates good from great QA engineers. Risk judgment: Not testing everything — testing the right things. Knowing what to prioritize under time pressure. Requirements analysis: Reading between the lines of a user story. Spotting what's missing before development starts. Collaboration: Working with developers without being adversarial. Timing feedback so it's useful, not frustrating.The Career Fork: Individual Contributor vs. Management
Around the senior level, you'll typically choose a direction:
Individual Contributor (IC) track:- Staff QA Engineer → Principal QA Engineer → Distinguished/Fellow
- Depth: You become the go-to expert on testing, quality systems, tooling
- You influence through expertise and mentorship, not headcount
- QA Lead → QA Manager → Director of QA → VP of Engineering
- Breadth: You build and develop teams, own roadmaps, interface with executives
- You influence through people, process, and organizational design
Neither is better. The right choice depends on whether you get energy from deep technical work or from developing people and leading teams. Both can lead to high impact and compensation.
Many companies now support both tracks explicitly — so you don't have to become a manager to advance. If your company doesn't offer an IC track above senior, that's useful information when evaluating your next role.
What Gets You Stuck at Each Level
Stuck at junior:- Waiting to be assigned tasks instead of identifying the next one
- Only testing what's documented
- Not investing in automation skills
- Doing great work but only for yourself — not helping others grow
- Avoiding strategic conversations ("that's not my job")
- Not developing depth in at least one area (automation, performance, security)
- Not taking ownership of outcomes, only tasks
- Avoiding conflict and hard conversations
- Not investing in the team's development
A Note on Certifications
ISTQB, CSTE, and similar certifications have value as signal for early-career moves (especially in markets where they're expected). But they don't substitute for practical skills. Hiring managers at most tech companies care far more about your Playwright fluency, GitHub portfolio, and ability to discuss real testing decisions than about certifications.
Invest in certifications if your target market values them. Invest in practical skills regardless.
The path from junior to senior is mostly about expanding scope: from "I test this feature" to "I own quality for this product area" to "I define how quality works on this team." The technical skills get you in the door. The scope of your ownership determines where you land.
→ See also: QA Engineer vs SDET vs QA Automation Engineer: What's the Real Difference? | Becoming a QA Lead: Responsibilities, Skills, and the Transition | QA Engineer Salary in the US 2026: By City, Experience, and Skill | How to Build a QA Portfolio That Gets You Hired (GitHub + Playwright)
