Onboarding Junior QA Engineers: A 30-Day Plan That Actually Works
The first 30 days of any engineering role are the highest-density learning period in a person's career at your company. The habits, patterns, and mental models they form in month one persist. A well-designed onboarding program doesn't just ramp up a headcount — it shapes the quality practitioner they will become.
Junior QA engineers have a particular onboarding challenge: they need to understand the product (to know what "correct" looks like), the architecture (to know where bugs come from), the test automation stack (to be productive), and the team culture (to know when to escalate vs. resolve independently). These are a lot of parallel tracks to run.
This 30-day plan structures them in sequence.
The 30-Day Roadmap
flowchart LR
A[Week 1\nSystem Orientation] --> B[Week 2\nManual Testing Deep Dive]
B --> C[Week 3\nTest Automation Entry]
C --> D[Week 4\nIndependent Delivery]
style A fill:#3b82f6,color:#fff
style B fill:#22c55e,color:#fff
style C fill:#f59e0b,color:#fff
style D fill:#ef4444,color:#fff
Week 1: System Orientation
The goal of week one is comprehension — not productivity. Productivity comes from comprehension.
Day 1–2: Product First
- Full walkthrough of the product as a new user
- Complete the onboarding flow from signup to first key action
- Document every question and confusion — these are candidates for UX bugs
- Goal: understand what the product is supposed to do, from the user's perspective
Day 3: Architecture Overview
- 1-hour architecture walkthrough with a senior engineer
- Cover: system components, data flow, key integrations (Supabase, Paddle, Redis)
- Junior engineer draws their own system diagram from memory afterward
- This forced recall exercise reveals gaps; fill those gaps before proceeding
Day 4: Environment Setup
- Local dev setup following the documented process
- Configured access to staging environment
- Access to test accounts at each plan tier (free, pro, enterprise)
- First time: note every step that was unclear or missing — update the docs
Day 5: QA Scope and Process
- Review existing test cases: what's automated, what's manual, what's not covered
- Review the last 5 deployments: what changed, what was tested, what shipped
- 1-on-1 with QA lead: team norms, escalation paths, communication expectations
Week 1 Milestone
The junior engineer can navigate the product confidently, understands the system architecture diagram, has a working local environment, and has documented at least 3 process gaps or missing docs items.
Week 2: Manual Testing Deep Dive
Before writing automated tests, understand what you're automating.
Day 6–7: Exploratory Testing Fundamentals
- Walk through exploratory testing principles: charters, time-boxing, tour-based approaches
- Junior engineer runs a 90-minute exploratory session on one feature area
- Debrief: what did they find? What did they miss? What questions emerged?
Day 8–9: Regression Testing Assignment
- Assign a specific feature area to own for regression testing
- Junior engineer writes the test cases for this area (not automated yet — manual test cases)
- Senior QA reviews and calibrates: what's missing? What's over-specified?
Day 10: Bug Report Writing Workshop
- Review 5 existing bug reports (good ones and bad ones)
- Junior engineer writes 3 bug reports from their exploratory session notes
- Goal: reproduce the defect from the report alone (unambiguous steps)
Week 2 Milestone
Junior engineer can write a clear, reproducible bug report and has written a complete manual test suite for one feature area.
Week 3: Test Automation Entry
Start with reading existing tests before writing new ones.
Day 11–12: Codebase Immersion
- Read the existing test automation codebase (don't write yet)
- Identify: folder structure, naming conventions, fixture patterns, page objects used
- Run the existing Playwright test suite end-to-end locally
- Write a 1-page "what I noticed" summary — where are the patterns clear? Where are they inconsistent?
Day 13: Pair Programming on Test Writing
- Senior QA writes one test (thinking out loud)
- Junior engineer writes one test with senior QA present
- Debrief: what was hard? What needed googling?
Day 14–15: First Independent Test Script
- Junior engineer converts one manual test case from their Week 2 work into a Playwright test
- Must include: proper fixture, page object usage, assertions, cleanup
- Code review by senior QA — same rigor as production code review
Week 3 Milestone
Junior engineer has written and merged their first automated test, following team conventions, with appropriate assertions and fixtures.
Week 4: Independent Delivery
Supervised independence — owning a deliverable with a safety net.
Day 16–18: Feature Testing Ownership
- Assign a newly shipped feature or upcoming feature for complete test coverage
- Junior engineer plans the test approach: what to test manually, what to automate, what to de-scope
- Presents the plan to QA lead before execution
Day 19–20: Test Execution and Bug Filing
- Execute the plan independently
- File all bugs using the team's bug report template
- Determine severity/priority independently; calibrate with QA lead afterward
Day 21: Retrospective and 30-Day Review
- What went well? What was hard?
- 3 things the junior engineer wants to go deeper on in month 2
- QA lead gives structured feedback: strengths observed, growth areas, specific goals for month 2
Week 4 Milestone
Junior engineer independently tests and provides QA coverage for a feature, including bug filing and a written test approach document.
The Companion Resource List
Provide this reading list at the start of week 1, with checkpoint discussions:
| Resource | When to Read | Discussion |
|---|---|---|
| "Lessons Learned in Software Testing" (Kaner, Bach, Pettichord) | Week 1 | End of week 1 discussion |
| Team's Playwright test suite | Week 3 | As part of codebase immersion |
| OWASP Testing Guide (skim) | Week 2 | Discuss security testing approach |
| Internal: Architecture decision records | Week 1 | After architecture overview |
| Blog: Debugging Flaky Tests in CI/CD | Week 3 | Before writing first tests |
| Blog: Writing Bug Reports Developers Love | Week 2 | Before bug report workshop |
What Good Looks Like at Day 30
By the end of 30 days, a successfully onboarded junior QA engineer should be able to:
- Navigate the product and identify obvious UX defects without guidance
- Write reproducible, well-structured bug reports at S2+ severity
- Run the full test suite locally and interpret failures
- Write basic Playwright tests following team conventions (with review)
- Describe the system architecture in a 5-minute verbal summary
- Know who to ask for each class of question
They should NOT yet be expected to:
- Own a full product area independently
- Architect test automation components
- Make independent PR approval decisions on merged tests
The 30-day plan is not about getting someone productive as fast as possible at any cost. It's about getting them productive in the right way — with the foundations that will make them excellent at 6 months and 12 months, not just functional at day 31.
Give your QA team visibility into what's shipping: Try ScanlyApp free and set up automated scans that catch critical regressions before any engineer needs to find them manually.
