Week 2: Strategy and planning
What happens
Based on the audit findings, the QA team designs the testing strategy:
- Test architecture decision: What ratio of unit/integration/E2E tests is right for your product
- Tool selection: Choosing frameworks based on your stack, not the vendor's preference. For a typical web application: Playwright for E2E, Jest/Vitest for unit, Pact for contracts.
- Priority backlog: The first 20-30 test cases ranked by risk coverage, starting with the highest-impact flows
- CI/CD integration plan: How tests will plug into your existing pipeline, with specific gate definitions
- Communication protocol: Daily standups? Weekly reports? Which Slack channel? How bugs are reported and tracked.
What you receive
A QA Strategy Document — a living document that evolves over the engagement:
- Testing architecture diagram
- Priority test backlog with estimated coverage by week
- CI/CD integration plan with timeline
- Communication and escalation procedures
- KPIs and targets for months 1, 3, and 6
What you should approve
Before week 3 starts, you should review and approve:
1. The tooling choices (make sure they fit your team's capabilities)
2. The priority order of test coverage
3. The communication frequency and format
4. The CI/CD gate definitions (what blocks deploys vs. what just reports)
Weeks 3-4: Foundation build
What happens
The QA team starts building the testing infrastructure and writing the first tests:
- Environment setup: Test environments, CI/CD pipeline modifications, test data management
- First smoke tests: 5-10 automated tests covering your most critical user journeys
- Pipeline integration: Smoke tests run on every PR and block merge if they fail
- First manual test cycle: Exploratory testing of the product's core flows, documenting bugs in your tracker
Deliverables each week
- Test execution report: what was tested, what passed, what failed
- Bug reports filed in your issue tracker (Jira, Linear, etc.)
- Demo of automated tests running in CI/CD
- Updated test coverage metrics
What you should see by end of week 4
- 5-10 automated smoke tests running on every commit
- First CI/CD gate active (tests block merge)
- 10-20 bugs filed from exploratory testing, categorized by severity
- The team is responsive in your Slack/Teams channel within normal business hours
Red flags at this stage
- No automated tests running yet after 4 weeks
- Bugs filed without clear reproduction steps or severity
- Communication gaps: you have to ask for updates instead of receiving them
- The team is using tools you didn't approve in the strategy document
Weeks 5-8: Coverage expansion
What happens
This is the highest-velocity phase. The QA team ramps up test coverage while running continuous exploratory testing:
- Automated test expansion: From 10 tests to 50-100, covering regression paths, API contracts, and integration points
- Visual regression testing: Automated screenshot comparison across key pages and viewports
- Performance baseline: First load test establishing response time and throughput baselines
- Sprint integration: QA team participates in sprint ceremonies, reviews stories for testability, and writes test cases during sprint planning (not after development finishes)
Typical metrics by week 8
| Metric | Target | Why it matters |
|---|
| Automated test count | 50-100 | Coverage of critical paths |
| Test execution time | Under 15 minutes | Fast enough to not block deploys |
| Bug detection rate | 15-25 bugs/week | Active exploratory and automated testing |
| Defect escape rate | Below 20% | Most bugs caught before production |
| CI/CD gate active | Yes, all stages | Automated quality enforcement |
What you should be doing
This is when you start evaluating whether the engagement is working:
- Are production incidents decreasing?
- Is your development team's velocity maintained or improved? (QA should not slow down development)
- Are bug reports useful and actionable?
- Is the communication meeting your expectations?
Months 3-6: Maturation and optimization
What happens
The engagement shifts from building to optimizing:
- Test suite optimization: Removing flaky tests, improving execution speed, adding risk-based test selection
- Advanced testing: Security testing, accessibility testing, mobile device testing based on product needs
- AI integration: Deploying AI testing tools where they add value (visual regression, test generation, API fuzzing)
- Knowledge transfer sessions: Teaching your internal team to maintain and extend the test suite
- Process refinement: Adjusting the testing strategy based on 3 months of data about where bugs actually come from
Monthly reporting
By month 3, you receive a monthly QA report covering:
- Bug statistics: found, fixed, escaped to production
- Test coverage trends
- Pipeline performance metrics
- Recommendations for the next month
- ROI calculation: cost of bugs prevented vs. engagement cost
The transition conversation
Around month 4-5, most clients fall into one of three paths:
Path A — Continue outsourced (40% of clients): The engagement is working, the cost is lower than hiring, and the team wants to keep the current model.
Path B — Hybrid model (35% of clients): Hire 1-2 internal QA engineers and reduce the outsourced scope. The partner handles specialized testing (security, performance, mobile devices). Internal team handles daily regression and sprint integration.
Path C — Full internalization (25% of clients): The outsourced team has built the testing infrastructure, established the process, and documented everything. The client hires an internal team and the partner does a structured handoff over 4-6 weeks.
All three paths are valid. The right choice depends on your product complexity, hiring market, and budget.
What it costs
Transparent pricing because you'll find out anyway:
| Model | Monthly cost (Israel market) | What's included |
|---|
| Single dedicated engineer | ₪15,000-25,000 | One QA engineer, 8 hours/day, full sprint integration |
| Team (2-3 people) | ₪30,000-60,000 | QA lead + engineers, strategy + execution, broader coverage |
| Project-based engagement | ₪40,000-80,000 | Fixed scope, defined deliverables, timeline-bound (e.g., pre-launch QA) |
These are Globalbit's ranges. Market rates vary. The comparison point: hiring a senior QA engineer in Israel costs ₪25,000-40,000/month in total employment cost, plus 2-3 months of recruiting and onboarding time.
How to evaluate if it's working
The three metrics that matter
After 90 days, three numbers tell you everything:
- Defect escape rate: What percentage of bugs reach production? Should be below 15% and trending down.
- Time to detect: How quickly after deploy are bugs found? Should be under 1 hour for critical issues.
- Development velocity: Has the team's shipping speed maintained or improved? If QA is slowing down development, something is wrong.
The conversation to have at 90 days
Ask your QA partner: "Show me the trend lines." If defect escape rate is flat, something isn't working. If it's dropping but slowly, that might be okay depending on your starting point. If it dropped sharply in month 2 and stabilized, that's healthy.
FAQ
What if we don't like the QA team assigned to us?
A good partner replaces team members if the fit isn't right. This should happen within the first two weeks if there's a mismatch. If you have to ask more than once, reconsider the partner.
Can we start with a pilot project instead of full engagement?
Yes. A common pilot: outsource QA for one product or feature area for 2-3 months. Measure results. Expand if it works. This reduces risk and gives both sides a chance to evaluate the fit.
How do we protect our IP with an outsourced QA team?
Standard NDA, code access limited to what's needed, and secure development practices. Any reputable QA partner has these in place already. If they don't mention it proactively, that's a red flag.
What's the typical engagement length?
6-12 months for initial engagement. Most clients who continue past month 3 stay for at least a year. The ROI improves over time because the team deepens their product knowledge and the test infrastructure matures. Ready to see what this looks like for your product? Let's talk.
