Skip to content

Senior QA Engineer · Bucharest, Romania

Bogdan Carcadea

Open to new QA roles
Portrait of Bogdan Carcadea

Five years of senior QA across AAA productions and live products. I build test automation on my own projects: Playwright and TypeScript with a Python API layer, Page Object Model, UI and API coverage, and GitHub Actions CI, including a bank-transfer suite that found and documented a real overdraft-enforcement gap. Looking to apply that professionally.

  • Automation
  • API
  • CI/CD
  • Web
  • Mobile
  • VR
  • Console
automated tests
40+
years in QA
0+
defects reported
9,950+
language stacks
2

About

How I think about quality

I write test automation and I run test strategy, and the two feed each other. My Playwright and TypeScript framework covers UI and API against real applications, with a Python API layer, Docker, and GitHub Actions CI running on every push. It is built the way a team framework is built: Page Object Model, shared fixtures, data-driven tests, and network interception, not a folder of throwaway scripts.

That automation sits on top of five years testing large, complex software: AAA productions at Ubisoft and EA, and now a multi-platform product where I am the only QA and own every quality decision from planning to release sign-off. Different industries share the same fundamentals: scope pressure, platform fragmentation, release risk, and the need for someone to say clearly what "ready" means.

The part of QA that matters is deciding what could fail, what that would cost, and what to check first. Automation removes the repetitive work so that judgment goes where it counts. A bank-transfer suite I wrote is a small example: it did not just pass, it surfaced a service that lets accounts go negative. That is the kind of finding automation should produce.

Case studies

Selected work

Personal project · Playwright, TypeScript, Pytest, Docker, GitHub Actions CI

QA Automation Portfolio: UI and API test framework

automated tests
40+
test suites
5
browsers
3
language stacks
2

The problem

Manual QA proves you can find bugs. It does not prove you can build the automation that catches them on every push. I built a production-style test framework, run against real applications rather than toy demos, to close that gap and to develop the capability I want to bring to a team.

Outcome

Found and documented a real overdraft-enforcement gap: the target bank's transfer service does not enforce overdraft limits and drives accounts negative. The suite verifies decimal precision on transfers, the one-cent boundary, and full-balance transfers. 40+ automated tests across five suites, two language stacks, and three browsers, green on every push.

What I did

  • Framework: a Page Object Model architecture in Playwright and TypeScript with 11 page classes, shared fixtures, data-driven tests, and network interception, running across Chromium, Firefox, and WebKit.
  • What is tested: five suites against live targets. A SauceDemo e-commerce UI suite, a restful-booker REST CRUD suite with authentication, a 12-test end-to-end suite against this portfolio site, an 8-test suite against my own live fitness PWA including ledger-precision checks, and a 6-test ParaBank demo-bank suite.
  • Second stack: an API layer in Python with Pytest alongside the TypeScript suites, the whole thing containerized with Docker so it runs the same locally and in CI.
  • How it runs: GitHub Actions CI executes the suites on every push and publishes HTML report artifacts, so every change is verified automatically and the results are inspectable.
  • Problem it solves: repeatable, reviewable regression coverage across UI and API that a manual pass cannot sustain, with money-critical checks the target systems actually need.

Personal project · C#, Unity Test Framework, AltTester

Match-3 Automated QA Framework

The problem

Manual test scripting for match-3 games does not scale: every new level means hours of case-by-case setup, and content updates quietly invalidate old coverage.

Outcome

New-level test setup time went from hours to minutes, and the framework keeps working as content changes.

What I did

  • Built a single reusable framework, with AI-assisted development in Claude Code, that runs automated suites for level validation, game-logic checks, and functional coverage across performance, visual, audio, event, notification, and monetization systems.
  • Simulated multiple player personas through configurable alter-ego profiles (distinct playstyle presets) across parallel multi-device sessions, validating personality-driven mechanics and progression loops.
  • Hunts and reports defects autonomously: extracting device logs, capturing screenshot and video evidence, and generating structured bug reports with full reproduction context.
  • Designed it to adapt to new levels and content updates instead of being rewritten for them.

Personal project · live PWA on Cloudflare Workers + Firebase

Fitness AI

The problem

A solo project run like a real product, to practice the engineering discipline QA usually observes from the outside: Git/PR workflow, release practices, and owning defects I wrote myself. It is also a live target for my automation suite.

Outcome

A live, working app, and a better understanding of the developer's side of the defect lifecycle. It changed how I write bug reports and how I design automation.

What I did

  • Built a predictive analytics engine: regression-based progress forecasting with confidence scoring, self-correcting calorie targets, and meal planning that respects dietary restrictions.
  • Integrated an AI conversational coach (Claude, Gemini, Groq) with persistent long-term memory and proactive daily briefings, maintaining continuity across sessions.
  • Implemented a gamification engine: XP progression, reward shop, wager challenges, power-ups, and clan boosts to drive sustained long-term engagement.
  • JavaScript, Firebase, Cloudflare Workers, and LLM API integration, developed end to end inside a PR-based workflow, then covered by an 8-test Playwright suite including ledger-precision tests.

Avantaj Play · 2025 to present

Sole QA ownership of a multi-platform product

The problem

A live product with four cross-functional teams and no QA function behind it. No inherited process, no second opinion. Every decision about what to test, when to automate, and what blocks a release is mine.

Outcome

Manual QA effort dropped by about half per sprint, the defect pipeline is used by the whole studio, and the QA function now scales beyond one person. Coverage extends to other internal products, including an internal specialized VR application.

What I did

  • Designed the QA strategy from zero: risk-based coverage, tiered regression scope, release criteria, and 10 to 20 new test cases per feature each sprint.
  • Introduced automated testing across core application flows using C#, Unity Test Framework, AltTester, and Python, removing repetitive smoke and regression passes.
  • Redesigned the Jira workflows and tracking boards; the reporting standard is now used daily by QA, development, art, and management.
  • Took over the department's technical hiring: running assessments, then training and mentoring the testers I helped bring in.
  • Produce end-of-sprint summaries for cross-functional stakeholders: completed and in-progress work alongside critical milestones.

Ubisoft · 2021 to 2025 · QC Tester to Quality Analyst Technician

Expert coverage across AAA productions

The problem

Productions like Assassin's Creed Shadows, Star Wars Outlaws, Assassin's Creed Valhalla, and Watch Dogs: Legion ship across PlayStation, Xbox, PC, and mobile, with a state-space no team can test exhaustively. Build cadence swung with context, from one or two builds a week in quiet phases to 8-10 a day near release.

Outcome

Contributed to an estimated 10,000+ reported defects across the portfolio, and was trusted as technical lead on select projects without holding the lead title.

What I did

  • Worked in a strike-team model: rotated onto projects needing senior coverage, delivered analysis and reports, moved to the next.
  • As Quality Analyst Technician, served as technical lead on select projects across dedicated sprint rotations: coordinating tester allocation, tracking KPIs, and reporting to QC leadership.
  • Applied risk-based, functional, and non-functional testing to keep coverage meaningful when exhaustive testing was impossible.
  • Supported milestone delivery, platform compliance, and certification across console generations, PC, and mobile.

Earlier: Quality Controller at Electronic Arts (contact person for the FIFA 20 demo, plus Madden NFL 20 and UFC 4). Other Ubisoft titles include Avatar: Frontiers of Pandora, Rainbow Six Siege, Skull and Bones, and The Crew Motorfest.

See every project I have worked on

Experience

Where I've owned quality

Sep 2025 to present

Avantaj Play

QA Engineer, sole QA owner

Full ownership of quality for a multi-platform product: strategy, automation, process design, release sign-off, plus the department's technical recruitment and mentoring.

Mar 2021 to Aug 2025

Ubisoft

  1. Quality Analyst Technician

    Jun 2024 to Aug 2025

    Strike-team role: expert coverage on assigned features and areas across projects; technical lead on select projects across sprint rotations, with tester allocation, KPIs, and reporting to QC leadership.

  2. QC Tester

    Mar 2021 to May 2024

    Testing, defect reporting, and test case design on AAA productions.

Four and a half years on AAA productions, growing from tester to analyst in a strike team coordinating expert testers.

Jul 2019 to Oct 2019

Electronic Arts

Quality Controller

First QA role, on some of the largest live sports titles in the industry, including serving as contact person for the FIFA 20 demo.

The full role-by-role history lives in the CV. This page is about the work.

Expertise

How the work breaks down

01

Automation & Frameworks

A Page Object Model framework in Playwright and TypeScript covering UI and API, with a second API layer in Python and Pytest, Docker, and GitHub Actions CI on every push with HTML reporting. Data-driven tests, fixtures, and network interception across three browsers. Production automation in C#, Unity Test Framework, and AltTester.

  • Playwright
  • TypeScript
  • Pytest
  • Python
  • API testing
  • Page Object Model
  • Docker
  • GitHub Actions
  • CI/CD
  • C#
  • Unity Test Framework
  • AltTester

02

Test Strategy & Risk

Deciding what to test, in what order, and what to consciously leave untested. Risk analysis before test cases, release criteria before release dates, and go/no-go input backed by evidence.

  • Risk-based testing
  • Test planning
  • Coverage design
  • Release criteria

03

Execution & Defect Management

10,000+ defects reported across my career. Reproducible reports, calibrated severity, and a defect lifecycle managed through to verified fixes.

  • Exploratory testing
  • Regression
  • SQL
  • Jira
  • TestRail
  • Xray
  • Equivalence partitioning
  • Boundary value analysis
  • Decision tables
  • State transition
  • Static testing

04

AI-Assisted Workflows

AI tools as accelerators for test design, documentation, automation scaffolding, and prototyping. Both personal projects were built this way, deliberately, to learn where AI-assisted development is strong and where it fails. Human judgment stays in charge of what ships.

  • Claude
  • Claude Code
  • Gemini
  • ChatGPT
  • Copilot
  • Cursor
  • Rovo AI

05

Platforms & Certification

PC, PlayStation, Xbox, Stadia, mobile, browser, and VR. Including certification requirements, input differences, and defects that only exist on one hardware generation.

  • Console certification
  • Compatibility
  • Mobile
  • VR/AR

06

People & Process

My entire career has run on Agile: sprint planning, dailies, retros, and QA embedded in the Scrum cadence rather than bolted on at the end. Plus technical recruitment, candidate assessments, mentoring testers through onboarding, and reporting standards adopted across teams.

  • Agile
  • Scrum
  • Technical recruitment
  • Mentoring
  • Jira workflow design
  • Stakeholder reporting

Selected technical details

For readers who want the specifics

How the automation framework is built and run

The framework uses a Page Object Model: 11 page classes that hide selectors and page mechanics behind intent-level methods, so a test reads as a scenario, not a DOM walk. Shared fixtures handle setup and teardown, data-driven tests iterate the same flow over varied inputs, and network interception lets me assert on and stub API traffic. UI runs across Chromium, Firefox, and WebKit; a Python and Pytest layer covers the API independently. Docker pins the environment so local and CI runs match.

GitHub Actions runs the suites on every push and uploads HTML report artifacts, which makes failures inspectable after the fact rather than only visible in a terminal. The value is not the count of tests, it is that the coverage is repeatable, reviewable, and gates change automatically instead of depending on someone remembering to run it.

Finding an overdraft-enforcement gap through automation

The ParaBank demo-bank suite targets money-critical behavior on purpose: decimal precision on transfers, the one-cent boundary, full-balance transfers, and overdraft handling. Writing tests around those boundaries is where the interesting finding surfaced.

The transfer service does not enforce overdraft limits: a transfer larger than the available balance succeeds and drives the account negative. I documented it as a finding with reproduction steps rather than forcing the test green. That is the point of automation around financial logic, it makes boundary behavior explicit, and explicit behavior is where the real defects live.

Where automation earns its keep

My rule: automate what is repetitive, deterministic, and boring (smoke passes, level validation, data setup, regression across UI and API) and keep human attention on what is exploratory, visual, or judgment-heavy. Automation that tries to replace exploration produces green dashboards and shipped bugs.

On my current professional project this split cut manual QA effort by about half each sprint: automated verification of stable flows in C#, Unity Test Framework, AltTester, and Python, freeing manual time for new features and edge exploration.

How I structure a test strategy from zero

When I joined a product with no existing QA process, the first deliverable was not test cases. It was a risk map: which features carry real money or user trust, which platforms diverge most, and where the team had already been burned. Test scope, depth, and automation candidates all derive from that map.

Regression scope is tiered: a small always-run core (money paths, session integrity, platform entry points), a per-area tier triggered by what a change touches, and a full sweep reserved for release candidates. The size of the test effort should track the size of the risk, not the size of the changelog.

Contact

Get in touch

The fastest way to reach me is email. For a full work history, download the CV.

LinkedInGitHubDownload CV