Open to senior QA automation / SDET roles
Maksym Biriukov, Senior QA Automation Engineer / SDET

Maksym Biriukov

Senior QA Automation Engineer / SDET

QA Automation Engineer with a track record of building test automation frameworks, CI/CD pipelines, and stable test environments. Recent projects include cutting pipeline execution time, eliminating false test failures caused by hardcoded test matrices, and automating environment synchronisation to remove an entire class of flaky results.

Projects

Selected work

Four projects, four classes of flake removed

01

Enterprise Hybrid Automation Framework & CI/CD Migration

Led the redesign of the test automation setup, moving it from a patchwork of UI and API scripts to a proper OOP-based framework, and separately ran the migration of the CI/CD pipeline from Jenkins to GitLab CI.

Page Object Model
API clients
GitLab CI
Docker
TestRail
Allure

Jenkins → GitLab CI

Full pipeline migration

Auto

TestRail result sync

Parallel

Containerised runners

The challenge

When I started on this, the test suite had a lot of problems typical of something that grew organically without much oversight: duplicated code everywhere, UI and API scripts that broke if you looked at them wrong, and parameterisation that was more or less hardcoded per test. Reporting was disconnected from everything else, too — someone had to manually go in and map results into the test management tool after every run. The Jenkins pipelines weren't much better; they were all written in Groovy and had turned into something people were afraid to touch, which slowed down every release.

What I built

  • OOP framework architecture

    Rebuilt the framework around a Page Object Model for the UI side and dedicated client wrappers for the API side, cutting down duplication significantly and making it easier for other engineers to pick up and extend.

  • Advanced parameterisation

    Built out proper data-driven parameterisation so the same test logic could run across different environments and configs without copy-pasting test cases.

  • Deep TMS integration

    Wired up native integration with TestRail so results synced automatically and stayed traceable back to the original test runs — no more manual mapping.

  • CI/CD modernisation

    Stabilised and extended the existing Groovy Jenkins pipelines first, then planned and executed the full migration to GitLab CI, including containerised runners and parallel execution, cutting pipeline run times noticeably.

Pipeline

Automation package

Parallel project branches

Project 1

  • Merge code
  • Docker image build

Project 2

  • Merge code
  • Docker image build

Project N

  • Merge code
  • Docker image build

Test execution

GitLab CI

Allure report

TestRail export

Automation package fans out per project, converges on GitLab CI execution, reports to Allure and TestRail.

02

Dynamic Test Parameterisation & Compatibility Engine

Came out of a recurring problem: test matrices were hardcoded, but not every test case actually applied to every algorithm we supported. That mismatch caused a steady stream of false failures, wasted CI time, and pipelines that would block for reasons that had nothing to do with real bugs.

Data-driven design
Compatibility rules engine
Runtime matrix generation

0

False failures from stale matrices

Runtime

Matrix built per active algorithm

Clean skips

With logged reason

The challenge

The challenge was building a framework flexible enough to ingest a dynamic list of algorithms, evaluate compatibility rules against them, and filter or generate test parameters on the fly — all without breaking pipelines already in use.

What I built

  • Compatibility abstraction layer

    Built a framework that treats algorithm compatibility as data rather than something baked into the test code.

  • Dynamic parameterisation

    The system reads the current list of active algorithms at runtime, checks each one against a set of compatibility rules, and constructs the test matrix dynamically — so tests only run where they're actually relevant.

  • Fallback handling

    Added logic so that when a test genuinely doesn't apply to a given algorithm, it gets skipped cleanly with a log entry explaining why, which made debugging pipeline issues much faster.

Pipeline

Active algorithms

Read at run time

Compatibility rules

Held as data

Compatibility evaluation

Rules checked per algorithm

Test matrix built dynamically

Run test

Algorithm is applicable

Skip cleanly

Logged with the reason why

The active algorithm list and the compatibility rules meet at runtime; each pair either becomes a test matrix entry or a clean, logged skip.

03

Scheduled Test Environment Update & Synchronisation Pipeline

Staging and QA environments had a habit of drifting away from what was actually in development over the course of a day, which meant nightly regression runs were sometimes testing against stale or inconsistent baselines — producing false positives and negatives that ate up debugging time for no good reason.

Cron scheduling
Deployment scripting
Env health checks
Nightly regression

2 h/week

Manual reset work removed

Nightly

Known-clean baseline

Cron

Hands-off trigger

The challenge

This called for a reliable, hands-off routine that could update environments with the latest dev/master code, redeploy the app so it applies its own data migrations, and verify stability, all within a tight window before the nightly suite triggered.

What I built

  • Scheduled orchestration

    Set up a pipeline triggered by cron ahead of the nightly test window.

  • Automated lifecycle management

    Built scripts that pull the latest dev/master code, update the environment, redeploy the app (which applies pending data migrations itself), and verify stability — so every nightly run starts from a known-clean state with no leftover artefacts. This eliminated manual environment reset work, saving 2 hours/week.

Pipeline

Cron trigger

Runs before nightly window

Automated lifecycle management

Pull latest dev/master code

Update environment

Redeploy app

Migrations run app-side

Verify environment stability

Known-clean environment

Nightly regression suite

Saves 2 hours/week

Cron fires ahead of the nightly window, rebuilds the environment end to end, hands a clean baseline to the regression suite.

04
Under NDA

Mobile Device Farm Test Automation Pipeline

Manual testing of iOS builds across a range of real devices was slow and inconsistent — someone had to build the app, distribute it to available devices by hand, and run through test scenarios one device at a time, which didn't scale as the number of supported device/OS combinations grew.

iOS build automation
Mobile device farm
Parallel execution
CI/CD triggers

~3x

Faster than serial device runs

30 min/day

Manual build work removed

Dynamic

Device targeting at run time

The challenge

The goal was to automate the entire cycle: pull the latest master code, build a fresh iOS app, deploy it to whichever devices were currently available on the mobile farm, and run the test suite against all of them — without someone babysitting each step.

What I built

  • Automated build pipeline

    Pipeline pulls the latest master code and builds a fresh iOS app on every run, cutting out the manual build-and-deploy work and saving roughly 30 minutes per day.

  • Dynamic device deployment

    The app is deployed automatically to whichever devices are available on the mobile farm at run time, instead of targeting a fixed, hardcoded device list.

  • Parallel test execution

    Tests are split roughly 3x across available devices and run in parallel, cutting total execution time compared to testing devices one by one.

Pipeline

Pipeline trigger

Triggered via CI/CD

Pull latest master code

Build iOS app

Saves 30 min/day

Device farm

Deploy to available devices

Run tests in parallel

Split ~3x across devices

~3x faster

Aggregate test results

Every trigger produces a fresh iOS build, fans out across whatever devices are free, aggregates one result set.

Skills

What I work with

Automation

Page Object Model
API client wrappers
Data-driven parameterisation
Mobile / iOS automation
Device farms

CI/CD

GitLab CI
Jenkins (Groovy)
Docker
Containerised runners
Parallel execution
Cron orchestration

Quality Engineering

TestRail / TMS integration
Allure reporting
Flake elimination
Environment lifecycle automation
Regression strategy

Let's talk automation

Test automation frameworks, CI/CD pipelines, and stable test environments. If you need a suite that stops lying to you, a pipeline that finishes before the standup, or an environment that resets itself — get in touch.

© 2026 Maksym Biriukov