Gennadii Nikitin
EN RU

How I work

The process I work by assumes that quality comes out of the whole delivery flow: by the time a build reaches testing, most of the problems have already been solved at earlier stages.

1. Start before the code exists

The expensive defects I have met often started with one phrase in a requirements document. It does not matter whether it was a misunderstanding or a double reading: any of it can cause trouble. So I join the design early: three-amigo sessions with the project manager and the developer, forming and tracking a list of open questions, and a testability check before anything is built. Why: a question in week one costs minutes, and the bug it prevents costs a release.

2. Design tests, don’t just write them

Boundary values, equivalence classes and state-transition diagrams decide what to check. Cases go through review like code and live not in someone’s memory or someone’s notes but in a test-management system (Allure TestOps, Qase), where the whole team can reach them.

3. A deliberate test pyramid

Unit and integration tests are written together with the code. They are cheap, simple and fast. They give us the base of the pyramid (or of whatever other shape fits), the layer we can lean on. And they let us keep the system layer thinner: the more complex layer, slower, more expensive to maintain and less reliable.

4. Automate where it pays off

Before investing in automation I try to understand three things: how often a test fails on its own, how much it costs to maintain, and how many real breakages it catches. Automation nobody trusts is worse than none.

5. Release gates with meaning

Tests before every merge into the main branch, and regular runs on a schedule.

A red pipeline holds the release until we know why it is red. Every failure gets triaged.

6. Performance is QA’s job too

Load testing is not one run against production before a release. These tests live in a dedicated environment and are owned by QA together with SRE. Benchmark, stability and peak-load scenarios are built from production logs, and the metrics are analysed after every run.

7. Production is part of the loop

Publishing to production always adds a new stage of work: support. I work through support requests and alerts first, hand them to the right owner, and review incidents with the team. What real usage shows (app versions, the topics people write to support about) decides what gets tested next and what gets described in the documentation.

8. Leave things reusable

After a project there is documentation, a knowledge base and a handover that someone else can pick up without me. Over a year, templates and quickstarts save a lot of time.

9. AI is a tool, and a human is accountable

An amazing tool. But it carries no responsibility.

I use LLMs for checklists, testing techniques, draft scenarios and test code. I assemble an orchestra of agents and pick the skills they need, trying to maximise efficiency.

But the result always goes through my review before it reaches the repository, and through my colleagues’ review before it reaches the main branch.

10. Own the project, not just your own area

When a gap opens up in the team, I am ready to widen my area of responsibility within what I am competent in. I have taken on part of a project manager’s work, spent a few weeks acting almost as a team lead, covered for a missing QA in a neighbouring team and brought new colleagues up to speed. A temporary staffing gap should not switch off the whole team.

The same process on a working project →