Stabilized flaky automation suites
Diagnose root causes — selectors, timing, test data, environment — and rebuild trust in the signal.
QA Automation Consulting · Web · API · Mobile · Performance · AI
Custom QA automation frameworks for teams that need reliable releases.
I help engineering teams design, build, stabilize, and scale test automation across UI, API, mobile, performance, and CI/CD pipelines.
Senior QA Automation Consultant · ISTQB Certified · Founder of TestBlocks · individual senior engineer — no agency overhead, no junior handoffs.
- Senior QA Automation Consultant
- ISTQB Certified
- 7+ years experience
- Java, TypeScript, C#, Python
- Playwright, Selenium, Cypress
- Rest Assured, JMeter
- CI/CD-ready frameworks
- Remote B2B consulting from Serbia
The reality
If any of this sounds familiar, let's talk.
These are the patterns I see in almost every engagement. None are unfixable — but they don't fix themselves either.
Manual regression delays every release
QA runs the clock on every sprint. Releases slip or ship without coverage.
Existing automated tests are flaky
Re-runs are routine, the suite is red more than green, and engineers stopped trusting the signal.
The framework has no real architecture
Tests are pasted-together scripts. Adding a new flow takes days; maintaining old ones takes more.
Tests aren't integrated into CI/CD
Automation runs on someone's laptop. Pipelines don't gate on quality. Bugs reach production.
API coverage is weak or missing
UI tests don't catch backend regressions. Contract breaks are found by users.
Performance risks are discovered too late
There's no load testing strategy. Outages and slowdowns surface during launches and traffic spikes.
QA team needs mentoring
Manual QA wants to grow into automation, but there's no senior in-house to guide framework decisions.
Why work with me
Senior automation, without the agency tax
The way I work is the difference. You're hiring an engineer, not a vendor — and that changes how every part of the engagement runs.
Senior, direct.
You work with the engineer doing the work — not a PM, not a junior, not a slide deck. The person scoping is the person writing the code.
Engineer first, consultant second.
I write production-grade framework code, review PRs, and ship. The deliverable is real software, not an architecture diagram and a goodbye.
Fixed scope, weekly deliverables.
Audits land in 1–2 weeks. Framework builds run on weekly check-ins. You always know what's coming next and what's done.
Real ownership transfer.
Engagements end with documented code in your repository, a handover session, and a team that can keep extending the framework. No vendor lock-in.
Builder, not just consultant
I also build TestBlocks.
Alongside consulting, I am building TestBlocks — an AI-assisted testing platform that helps teams import existing test assets, generate baseline UI/API coverage, run tests locally or in CI, and maintain automation with AI support.
That product work keeps my consulting close to real QA problems: slow regression, flaky tests, weak coverage, poor handover, and automation frameworks that are hard to scale.
Track record
Technical proof, not just consulting slides.
I build automation systems hands-on: framework architecture, Playwright/Cypress/Selenium implementation, Rest Assured API suites, CI/CD integration, reporting, test data strategy, and team handover.
Public examples and templates are being prepared on GitHub to show the same engineering standards I use in client work.
Built production-grade automation frameworks
Playwright, Selenium, Cypress, Rest Assured — modular, reviewed, owned by the team after handover.
Trained QA teams to own automation
Workshops, pair-programming, and code review that turn manual QA engineers into automation contributors.
Services
QA automation services for teams that ship
Engagements grouped by the business outcome they deliver — not just the tools involved. Click the one closest to your situation; the contact form will know what you meant.
QA Automation Frameworks
Production-grade Playwright, Selenium, Cypress, WebdriverIO, and Appium frameworks engineered like real software — modular, reviewed, owned by your team.
Deliverables
- Framework architecture (page object / screen-action structure)
- Test data strategy and environment configuration
- Reporting (Allure, HTML, dashboards)
- CI/CD execution and gating
- Documentation and team handover
Outcome
Your team owns a stable, extensible automation framework wired into delivery — not a brittle script collection.
API Test Automation
Reliable, environment-aware API suites that catch contract breaks before production — built with Rest Assured, Postman, Supertest, or SoapUI.
Deliverables
- API test suite covering critical endpoints
- Request/response models and shared utilities
- Data-driven and environment-based execution
- Negative and contract-style checks where useful
- CI integration and reporting
Outcome
Backend regressions are caught at commit time, not in production — and the API layer is covered independently of the UI.
Performance Testing
Load, stress, spike, and smoke testing with a strategy and reports that engineers and stakeholders can both act on.
Deliverables
- Load test scripts (JMeter or Artillery)
- Smoke performance checks for CI
- Baseline metrics and SLAs
- Bottleneck report with root-cause analysis
- Recommendations for engineering and infra
Outcome
Performance risks are surfaced before launches and load events — not discovered during them.
QA Automation Consulting & Audit
Strategy, architecture review, and stabilization for teams who already have automation but aren't getting value from it.
Deliverables
- Framework and code review
- Flakiness root-cause analysis
- Coverage gap report
- Practical roadmap and prioritized action plan
- CI/CD and reporting recommendations
Outcome
A clear, defensible plan for what to fix first — and the engineering depth to execute it.
AI-Assisted QA
Bring AI into your QA process where it actually saves time — test design, coverage analysis, and authoring acceleration through TestBlocks.
Deliverables
- AI-assisted test case design
- Coverage analysis support
- Faster automation planning
- QA workflow productivity improvements
- Practical integration into existing QA processes
Outcome
Your QA team moves faster on the parts that benefit from AI — without overpromising what AI can replace.
Workflow Automation
Automation goes beyond testing. I build internal tools and scripts that take repetitive web, mobile, and desktop work off your team's plate.
Deliverables
- Browser and web automation
- Data extraction and reporting pipelines
- Admin panel and form workflows
- Internal tools, schedulers, and scripts
- Documentation and ownership transfer
Outcome
Repetitive operational work runs reliably in the background — your team gets that time back.
Training & Mentorship
Upskill your manual QA engineers into automation engineers, or coach an existing team on best practices, framework design, and CI integration.
Deliverables
- Team workshops (Java/Selenium, Playwright, API)
- 1:1 mentoring and pair-programming
- Framework maintenance best practices
- Code review of internal QA contributions
- Long-term ownership transfer
Outcome
Manual QA engineers become automation contributors — and your team stops depending on external help to extend the framework.
Tech stack
Tools picked for the job, not the resume
Tooling is a means to an end. Below is what I work with day-to-day — selected based on your stack, team, risk profile, and where you actually want to be in 12 months.
Languages
- Java
- TypeScript
- JavaScript
- C#
- Python
- Groovy
- SQL
Web Automation
- Playwright
- Selenium
- Cypress
- WebdriverIO
API Testing
- Rest Assured
- Postman
- SoapUI
- Supertest
Mobile Automation
- Appium
Performance Testing
- JMeter
- Artillery
- Lighthouse
BDD, Test Runners & Reporting
- Cucumber
- SpecFlow
- TestNG
- JUnit
- NUnit
- pytest
- Mocha
- Chai
- Allure
CI/CD & Build
- GitHub Actions
- Jenkins
- GitLab CI
- Azure DevOps
- AWS Pipelines
- Maven
- Gradle
- npm
- Docker
Test Management
- Qase
- TestRail
- Xray
- Jira
Code Quality & Reliability
- SonarCloud
- axe-core
- Sentry
AI-Assisted QA
- TestBlocks
- AI-assisted test design
- AI-assisted coverage analysis
How I work
A predictable engagement, not a black box
Every engagement follows the same six steps. You always know what's happening this week and what you're getting at the end.
- 01
Discovery call
30 minutes. Your product, stack, release cadence, and where QA hurts most. No deck, no pitch.
- 02
QA & automation audit
Tests, framework, CI/CD, and process — reviewed and written up with prioritized findings.
- 03
Strategy & architecture
A concrete proposal: tooling, structure, scope, timeline. Tied to outcomes, not buzzwords.
- 04
Framework build / implementation
Production-grade automation, written like real software — modular, reviewed, in your repository.
- 05
CI/CD & reporting integration
Pipelines, gates, dashboards, Allure / Qase / TestRail. Failures point to the broken line.
- 06
Handover, documentation & training
Your team owns it. Documented, taught, and supported as long as you need.
What you receive
Concrete deliverables, in your repository
Engagements end with real artifacts your team owns — not slide decks. Below is what typically lands in your repo and your pipelines after a build or audit.
Automation framework repository
Production-grade framework code, modular and reviewed, committed directly to your Git repository.
Test architecture documentation
Written explanation of structure, layering, conventions, and extension points — for your engineers, not just for you.
CI/CD pipeline setup
Tests wired into GitHub Actions, Jenkins, GitLab, Azure DevOps, or AWS — with parallelization, sharding, and gating.
Reporting dashboard / configuration
Allure, HTML reports, or test-management dashboards — pointed at the right environments and the right people.
Test data and environment strategy
How tests get the data they need, how environments are switched, how secrets are handled. Documented and repeatable.
API test suite
Environment-aware API tests covering critical endpoints — Rest Assured, Postman, Supertest, or SoapUI.
Performance baseline report
Smoke load tests in CI, baseline metrics, and a written report on where the system bends and where it breaks.
Handover session
Live walkthrough of the framework with the engineers who will own it. Recorded if useful.
Team training notes
Where useful, structured notes and exercises for upskilling manual QA into automation contributors.
No lock-in
The framework is delivered to your repository, documented, and structured so your team can continue extending it. No vendor lock-in, no recurring license, no hostage code.
Typical outcomes
What I help teams achieve
Engagements vary, but these are the outcomes I aim for from the first week onwards. They map to release confidence, engineering velocity, and reduced QA cost.
Cut regression from days to minutes
Replace manual cycles with pipelines that run on every commit and gate every release.
Stabilize flaky automation
Diagnose root causes — selectors, timing, test data, environment — and rebuild trust in the signal.
Build frameworks engineers actually maintain
Code that's readable, layered, and reviewed. No QA-only silos that decay the moment someone leaves.
Wire tests into CI/CD with real reporting
GitHub Actions, Jenkins, Allure, Qase, TestRail. Failures point to the broken line, not 'something broke'.
Improve release confidence
Deploys stop being stressful. Hotfix rate drops. Engineering and product start trusting the green check again.
Train internal QA to own automation
Workshops, pair-programming, and documentation that turn manual QA engineers into automation engineers.
Free resource
Free QA Automation Audit Checklist
A practical checklist to evaluate your current automation framework, CI/CD setup, API coverage, flaky tests, reporting, test data, and release readiness.
No email gate, no fluff. Score yourself honestly — the gaps are where the biggest wins are.
Stop guessing what's wrong with your QA.
30-minute call, no slides, no pitch. I'll walk through your stack and where it hurts — you walk away with a clearer picture either way.
Automation Audit Sprint
What you get from an Automation Audit
Concrete deliverables, not a generic slide deck. The goal is a practical technical report your team can use to improve automation immediately.
- Framework architecture review
- Flaky test and reliability analysis
- CI/CD pipeline review
- API, UI, and performance coverage gap analysis
- Test data and environment review
- Reporting and debugging recommendations
- Prioritized automation roadmap
- Quick wins and long-term improvements
- Handover call with next-step recommendations
Engagement models
Pick the engagement that fits where you are
No fixed list prices — every engagement is scoped to the team, stack, and what success looks like. Quotes back within 48 hours of the discovery call.
Automation Audit Sprint
Best for
Teams with existing automation that is flaky, slow, or hard to maintain.
Includes
- Framework and code review
- CI/CD and reporting review
- Coverage gap analysis
- Written audit report
- Prioritized roadmap
Outcome
A clear picture of what's broken and a defensible plan for fixing it — technical and business-friendly.
Custom Framework Build
Most commonBest for
Teams starting from scratch or migrating to Playwright, Selenium, Cypress, or API automation.
Includes
- Framework architecture and implementation
- Initial coverage for critical user journeys
- Reporting and dashboards
- CI/CD integration and gating
- Documentation and team handover
Outcome
A production-grade framework in your repository, structured so your team can keep extending it.
Ongoing QA Automation Partner
Best for
Teams without dedicated automation hires who need senior support every month.
Includes
- Test maintenance and expansion
- CI/CD and reporting upkeep
- Coverage for new features as they ship
- CI monitoring and triage
- Coaching and code review for internal QA
Outcome
A senior automation engineer in your sprint cadence — without the cost of a full-time hire.
Workflow Automation Project
Best for
Operations or product teams with repetitive browser, data, admin, or reporting work outside testing.
Includes
- Browser, web, mobile, and desktop automation
- Data extraction and reporting pipelines
- Internal tools and scheduled jobs
- Documentation and ownership transfer
Outcome
Repetitive operational work runs reliably without human intervention — your team gets the time back.
Not sure which fits? Most engagements start with a 30-minute discovery call. I'll help you figure out the right shape.
Fit check
Best fit
This work is most effective when the team wants senior automation ownership, clear architecture, and practical delivery improvements — not just more test scripts.
This is a good fit if:
- your team already ships software and QA is slowing delivery
- you need automation architecture, not just more scripts
- you want tests running in CI/CD with useful reporting
- you need API, UI, mobile, or performance coverage that can scale
- you want internal ownership after handover
- you want practical AI-assisted QA workflows without hype
This is not a good fit if:
- you only need temporary manual testing capacity
- you want the cheapest possible implementation
- you do not want engineers involved in test architecture decisions
- you are looking for a generic outsourced QA agency
- you want automation without maintenance ownership
AI-Assisted QA
AI-assisted QA in client engagements
AI can accelerate QA work, but it should not replace engineering judgment.
In client engagements, I use AI carefully for test design support, coverage analysis, automation planning, documentation, and workflow acceleration. Generated output still needs review, prioritization, and ownership by experienced engineers and QA professionals.
- Test design support
- Coverage analysis
- Automation planning
- Documentation acceleration
- Workflow acceleration
The TestBlocks connection
Building TestBlocks — an AI-assisted testing platform — keeps me close to what AI can and can't do in real QA work. Lessons from product feed directly into how I scope AI use in client engagements.
No hype. AI as accelerator, not replacement.
About
About Aleksandar Stojanovic — Senior QA Automation Consultant & TestBlocks Founder
Aleksandar Stojanovic — Senior QA Automation Consultant and founder of TestBlocks. ISTQB Certified, with 7+ years designing, building, stabilizing, and scaling automation systems across UI, API, mobile, performance, and CI/CD.
My work combines hands-on framework engineering, test architecture, QA process improvement, and practical AI-assisted testing workflows.
Based in Serbia, working remotely with engineering teams in Europe and the US. Engagements are remote, async-friendly, and structured around clear weekly deliverables.
I work as an individual senior consultant — no agency overhead, no junior handoffs, no PMs translating between you and the person doing the work. The person scoping is the person writing the code.
FAQ
Common questions before you reach out
If your question isn't here, send it via the contact form below — I usually reply within 24 hours.
Can you work with our existing framework?
Yes. I can review what you have, fix architecture and stability issues, expand coverage, and integrate it with CI/CD without scrapping the work already done.
Can you build a framework from scratch?
Yes. Most engagements start with a clean architecture — framework structure, test data strategy, reporting, CI/CD, and documentation, production-grade from day one.
Can you migrate Selenium tests to Playwright or Cypress?
Yes — full migrations or incremental ones where the new framework runs alongside the old until parity is reached, so the team isn't blocked.
Can you fix our flaky tests?
Yes. Stabilization is one of the highest-ROI engagements I run. The fix is rarely 'add a sleep' — it's diagnosing selectors, test data, environment, and architecture, then patching the root cause at the right layer.
Can you integrate tests into CI/CD?
Yes — GitHub Actions, Jenkins, GitLab CI, Azure DevOps, and AWS pipelines, with parallelization, sharding, reporting, and gating.
Can you work part-time or project-based?
Both. Fixed-scope projects, audits, and ongoing monthly engagements. Remote, async-friendly, with clear weekly deliverables. Contracts and IP terms standard.
Can you train our QA team?
Yes. Workshops, 1:1 mentoring, pair-programming, and code review. Most teams want a mix: a working framework plus the skills to own it long-term.
Can you help if we don't have QA engineers yet?
Yes. I can act as a fractional senior QA automation engineer — building the foundation and the framework so your engineering team has a reliable test layer while you hire.
Can you automate business workflows outside testing?
Yes — browser, web, mobile, and desktop automation for repetitive operational work. Data extraction, form filling, admin workflows, internal tools, scheduled jobs.
Do you provide documentation and handover?
Always. Every engagement ends with documentation in your repository, a handover session, and (where useful) team training notes. The framework is structured so your team can keep extending it without me.
What happens next
What happens after you book a call?
Calm, professional, no pressure. A simple sequence so you know what to expect.
- 01
I review your current QA process, automation setup, and release pain points before the call.
- 02
On the call, I identify the highest-impact automation opportunities for your stack.
- 03
You leave with a clear recommendation: audit, framework build, migration, ongoing support — or no engagement if it's not a fit.
The first call is focused on understanding scope and identifying whether I can help. No pressure, no hard sell.
Contact
Let's talk automation.
Tell me what you're working on. Discovery call within 24 hours of your message — I read every email myself.