Programme

How often do we see bug reports like “a button doesn't work” without screenshots or any details? Unfortunately, it happens, and no one is immune. To reduce the likelihood of an empty ticket, we decided to write a simple error-catching tool to quickly respond and retrieve error data, even if we forget or can't open DevTools. This is how ErrorMonitor came into being, and I'd like to tell you about it.

This tool will be useful for testers, analysts, and support specialists to speed up localisation and bug fixes.

A BPMN process can run for weeks, call dozens of external systems, and spawn subprocesses. Unit tests verify the logic of each step in isolation, while BPMN tests with mocked delegates check the route, but with stubs instead of real code. Bugs at the seams between processes and subprocesses, timers and external events are invisible to both approaches. 

This talk presents an E2E framework for Camunda that runs the entire path from a Kafka event to the final state with a real engine and real BPMN routing, yet zero external dependency. It covers three key techniques: synchronising with the asynchronous engine via polling the REST API, fast-forwarding timers without touching system clocks, and isolating tests for parallel execution in a shared infrastructure. 

We will also explain how we integrated these tests into the development workflow, where we still stumble, and what compromises we have accepted.

My name is Vadim, and over the course of my career in testing I've conducted hundreds of interviews… and I’d like to talk about that :)

In this talk, I will share the outcome from my experience and explain how to prepare and conduct a perfect interview — what you should and should NOT do.

I will describe the approach that we've come to at Alfa Bank Belarus and share interesting, funny and ridiculous cases from my interviewing practice.

If you are not conducting interviews but currently participating in them as a candidate, you'll find it useful to see what's going on behind the curtains on the side of the hiring companies. At the end of the talk, I'll share a couple of suggestions for the candidates as well.

In this talk, we will examine fear as a complex system. We will break down the “modules” it consists of, understand how they interact, and identify the moment when a failure occurs. You won’t leave with a motivational slogan like “don’t be afraid,” but with a concrete algorithm that turns “total panic” into a clear action plan and the energy needed to take a bold step.

User feedback is one of the most valuable and at the same time one of the most challenging sources of information about a product. Comments, complaints, low ratings and analytics data rarely look like clear bug reports. They are subjective and often contradict each other. However, this feedback is where real problems and broken user flows are typically hidden.

In this talk, we will discuss how a QA engineer can work with user feedback as a testable object, not just as noise. I will show how UX hypotheses are formed from scattered user comments and behavioural data, and how a tester helps make these hypotheses testable and technically valid.

We will walk through the full feedback-to-testing process: from analysis and classification of feedback to formulating UX hypotheses, selecting appropriate testing methods and validating the results.

Let’s dive into the world of high‑performance automated tests and figure out how to speed up their execution manifold. We will guide the listener through the evolution of multitasking in Python, examining each approach — threading, multiprocessing, and asyncio — not only in theory but also through practical code examples using the tools pytest‑parallel, pytest‑xdist, and pytest‑asyncio. 

 We will touch upon the future of Python, discussing how disabling the GIL (PEP 703) and advent of subinterpreters (PEP 734) could drastically change the landscape of multitasking test execution. In the end, you will get a clear algorithm and a handy cheat sheet for selecting the optimal tool for your tasks so that you can immediately apply the acquired knowledge in practice.

Do you know what to do if your company starts using vibe-coding in projects?

Are you ready?

As part of the QAIshnitsa activity, we invite you to explore approaches and tools for ensuring the quality of applications built with LLMs.

We encourage you to team up and find the necessary expertise among conference participants. Were you short of an experienced specialist in a particular field? Put a call-out in the conference chat — someone will definitely step in to help.

What participants should bring:

• a laptop with Android Studio installed (we’ll help you set it up)
• your favourite LLM (or willingness to buy one)
• feistiness for vibe-testing!
• a team of like-minded people — or the courage to go solo.

Automated and manual testing teams regularly encounter issues with test accounts: passwords are shared between testers and CI, accounts are used in parallel, become locked during test runs, the root causes of test failures are difficult to trace.

This talk explores the experience of creating and implementing a User Pool — an infrastructure service for the secure storage, authorisation, and monitoring of test accounts.

I'll cover:
• why storing passwords in config files, Excel and secret vaults does not solve the problem of concurrent access;
• why off-the-shelf IAM solutions such as Keycloak or Cognito are poorly suited to testing needs;
• how to implement authorisation in tests without exposing passwords to testers and autotests;
• how a locking mechanism can prevent simultaneous use of the same account;
• how to organise auditing and monitoring of test account usage;
• how the User Pool operates in real-world scenarios involving complex authentication flows.

The biggest nightmare of a QA Head is not bugs — it’s an uncontrollable “zoo” of processes, endless meetings for the sake of meetings, and constant firefighting. QA turns into an isolated island, quality suffers, and conflicts escalate.

We analysed everything that explicitly and implicitly intersects with testing. As a result, we rebuilt the QA department (redefining its role as a centre of expertise) and redesigning the architecture of interaction both within QA and beyond it. Today, QA representatives collaborate with all roles in the technical department — from engineers (Dev, DevOps, CRE) to the CTO.

We also developed practical guidelines on how to structure communication with different stakeholders: which language to use, and which issues can realistically be resolved with whom — without empty discussions. The resulting interaction architecture enables QA to adapt quickly to the company’s needs, maintain the required level of quality, and continuously improve it.

This workshop focuses on integrating AI agents into a QA engineer’s daily routine. Using backend auto-tests as a practical example, we will explore how to delegate routine tasks to AI: fixing technical debt, generating complex data structures, and performing mass refactoring.

The session is designed for anyone striving to automate their workflows, from beginners to seasoned specialists. We will demonstrate how to transform AI into an effective assistant working directly within the IDE.

By the end of the workshop, participants will have a clearer understanding of which tasks are best suited for AI delegation and how to practically achieve results while maintaining full control over the process.

Technologies are updating faster than ever, and under the influence of AI, the role of QA is being significantly reshaped.

The tools, technologies, and tests are no longer what they were just three years ago. Fears of new and dynamically changing processes can hinder our progress, while robots in the form of AI offer incredible new opportunities.

What we'll talk about:

• Our professional fears: deskilling, FOMO, and cognitive noise
• Their impact on each specialist and the path they open for further evolution in the profession
• The concept of the future tester, combining engineering, analytics, AI, and strategic thinking, shaping a new professional profile for the coming years
  
  

P.S. There will be a minimum of subjectivity and a maximum of major research.

In the talk, we will examine the biggest corporate mistakes in AI adoption using real-world case studies — from flawed recommendation models and biased HR automation to autonomous system failures and risky predictive algorithms. By breaking down what exactly went wrong, we will reveal recurring patterns: data biases, weak metrics, lack of oversight, and unrealistic expectations about AI capabilities.
Yet the overarching message is constructive: AI is an extraordinary, highly valuable technology, and organisations absolutely should adopt it — but they must do it wisely. With thoughtful data practices, solid processes, robust testing, and a clear understanding of its limitations, AI becomes a driver of growth rather than a source of risk. These cases will show how to harness AI effectively while avoiding costly failures.

Soft skills — what a powerful phrase!

In today’s IT world, people with strong soft skills are highly valued. It’s often said that hiring decisions should prioritise soft skills, while hard skills can be developed along the way. Being an in-demand professional who communicates thoughtfully, resolves conflicts, plans effectively, and stays self-organised sounds ideal.

But… what is the other side of soft skills, and what is their “price”? That’s what I will reveal in this talk.

Building a scalable and maintainable automation system isn't just about choosing the right tools, it's also about the right architecture.

In this talk, we'll explore how combining the principles of Clean Architecture and Python metaprogramming enables building frameworks that easily adapt to changes, minimise code duplication, and grow alongside the project. 

You'll learn how to use decorators, descriptors, __getattr__, __init_subclass__, and other Python mechanisms to automate routine tasks: from finding page elements to dynamically creating API methods. 

I'll show real-world examples from practice, such as making PageObject smarter, switching between Selenium and Playwright without rewriting tests, and managing framework behaviour through configuration. 

This talk will be useful for QA engineers developing their own frameworks, as well as for technical leaders looking to improve the quality and flexibility of their automation systems.

There’s very little time left before the release. The date has already been announced, marketing has made its promises, and new features are still appearing. The testing team understands one simple thing: it’s impossible to test everything.

In this game, you work as a team member managing testing resources ahead of a release. You must decide where to invest your time: regression testing, exploratory testing, automation, or putting out yet another fire. Every decision is a trade-off between speed, risk, and final quality.

As the game unfolds, unexpected events will arise: new business inputs, changes in requirements, failing automated tests, missing team members. You’ll need to rethink your strategy and negotiate within the team.

It could be fun — if it weren’t so real. After this simulation, it becomes clear how you prioritise and make your choice: releasing — or testing.

The number of development standards is growing year by year.
The usual development and testing paradigm may change significantly with the introduction of new requirements and constraints, so it is best to be prepared for this in advance.

In this talk, we will look at the current state of affairs in secure (and not so secure) development from a testing perspective.
We will explore the standards themselves: what they contain and who they apply to.
And, of course, we will discuss the future: what lies ahead and what we should be preparing for :)

Most talks on automated testing focus on approaches and frameworks, overlooking auxiliary components like logging, reporting, custom assertions, retries, waiting and others. However, the lack of a solid implementation of these components can become a source of serious problems later on.

In this talk, I’ll explain why it’s important to think about these components from the very beginning of a project: how good logging and reporting simplify debugging and result analysis, thoughtful integrations eliminate boilerplate code, quick access to frequently used functions accelerates test development, clear test structure improves readability, convenient retries make tests durable, clear and understandable project structure keeps your project free from helpers chaos.

I’ll also outline a set of supporting components that are essential for comprehensive automated testing of any application and show their practical implementation in Python.

Product quality can begin to degrade long before it becomes obvious.
In this talk, I will present an approach to early detection of crisis states through analysing the dynamics of key metrics.

I will explain how, based on five criteria and simple statistical methods — without using machine learning — to build a system that not only reflects the current state, but also forecasts when a team may enter a “yellow zone” and how many weeks remain before reaching a “red zone”.

I will demonstrate how this works using real examples from my team’s practice: from collecting data in Jira to decision-making.

Who it's for: team leads, QA leads, product managers, and engineers who want to replace reactive responses with proactive quality control.

The focus of the talk is on practical implementation: selecting metrics, setting thresholds, collecting data, and introducing a culture of predictive analysis within the team.

The round table “Engineering Culture and QA” is a discussion for those who want not just to test, but to change processes and the surrounding culture.

We’ll explore what engineering culture really is, how it affects quality and the role of QA, why culture matters more than any strategy, and how to grow a mature team where quality is not a department, but a shared responsibility.

The session will feature real-world cases, common myths and challenges, and an analysis of typical mistakes.
Format: live and interactive, with polls, mini-debates, and questions from the audience.

You’ll leave with a clear understanding of how engineering culture influences your daily work, what prevents it from developing, and what you can start changing as early as tomorrow.

What to do when testing becomes the bottleneck in development, and the high workload of testers slows down the delivery of business value and increases the risk of errors?

The solution may be a standardised process to integrating AI into QA processes, which covers all stages of shift-left testing: from requirements testing to autotest generation. 

The results of such an implementation speak for themselves:

•  A fourfold acceleration of testing activities.
•  Save 75% of the time for creating test documentation (5-6 hours → 1.5 hours).
•  Speeding up the writing of autotests by 60-70%.

The talk describes a ready-made path from pilot to standard, with specific examples, metrics, artifacts, and practical recommendations for starting implementation.

QA engineers often perceive a Zero Bug Policy (ZPB) as a source of stress and additional reporting overhead. But what if we use this metric as a tool to identify and solve systemic team problems?

In this talk, I'll share practical experience of transforming chaos in bug management into a controlled process. Using the “Order and Payments” stream at Yandex Lavka as a case study, I'll demonstrate how we reduced ZBP from 1000 to 150 over 9 months while decreasing QA workload and increasing development team engagement.

I'll explore five key principles of a systematic approach: process regularity, priority transparency, focus on user problems, measurability of improvements, and involvement of the whole team. I'll present specific tools: from dynamic prioritisation of DUTY tickets to DSAT analysis of customer dissatisfaction.

The talk will be useful for QA engineers and leads who want to turn bug handling from a constant source of stress into an efficient process.

In this talk, I will share our experience of implementing the QA Notes practice into our development and testing process.

QA Notes is a special template completed by a developer before moving a task to the “Ready for testing” status—most often during task estimation or at the code review stage. This document accompanies every task that requires testing and contains all the essential information needed to hand it over correctly to QA.

As a result of this practice, we improved key metrics: communication time between QA and developers decreased, and overall testing time was reduced accordingly.

Implementing QA Notes is a low-cost and effective way to enhance collaboration quality, improve testing quality, and accelerate processes.

Today, QA Notes is an integral and natural part of our team's daily workflow.

This talk will be useful for anyone looking to increase the efficiency of task handover to testing more efficient and strengthen communication between development and QA.

This talk presents the practical journey of introducing AI into testing within a company operating under strict security constraints.

We will demonstrate the evolution of AI usage:

• from generating test cases based on requirements,

• to supporting manual testing,

• to building a structured knowledge base,

• to generating automated tests,

• and ultimately to a continuous delivery model for automated tests.

We will explore:

• why “raw” vibe coding does not scale in business environments,

• why custom AI agents are not always justified,

• how a universal engineering prompt can replace building your own agent,

• how to integrate AI into CI/CD without complex AI infrastructure.

We will share real-world constraints, the economics of adoption, and measurable efficiency metrics.

Key idea:

AI becomes part of the team not when it is intelligent, but when it is embedded into rules, standards, and processes.

The sheer number and variety of existing competency matrices in testing can be overwhelming, and even if you build one tailored to your needs, it usually ends up being of little use. In this talk, we will show how a competency matrix can be transformed from a static table into a dynamic development ecosystem using AI agents, automated data collection, and adaptive competency assessment. We will also discuss why a standard matrix without AI fails to create real value, and how to build a genuine tool for the growth and development of testers.

When a team works smoothly and consistently delivers good results, many people take it for granted. But how many obstacles, problems and difficulties a young team have to overcome to become a strong and effective unit within a department.

During the debate, we will examine situations that can derail a group of people on their way to becoming a true team and discuss different sides of various solutions. We will try to outline the right path around common pitfalls and warn the round table participants against taking the wrong turn.

Join us — it will be not only interesting, but also useful!

Integration testing in large-scale ecosystems is a real challenge and an endless race.

In this talk, you'll learn how the InfoTeCS team developed their own integration testing system to not only test products, but also to reach a new level of quality.

Our system allows teams to visually model and run arbitrary test scenarios, creating the desired framework from the building blocks of existing tests and relevant assets. The system combines three elements: the flexibility of manual testing, the automated tests developed by teams, and the simplicity of preparing a test infrastructure.

A QA competency matrix (CM) often sounds like a verdict: “now you will be measured and compared.” As a result, leads hesitate to introduce it, and QAs worry about being assessed “incorrectly” or “by a spreadsheet without context.”

In this talk, we will explore how to build a CM that truly works: supports team growth, makes expectations transparent, and increases maturity rather than anxiety. Most importantly, we will show how to embed the CM into the company’s organisational structure so it stops being a “box-ticking spreadsheet” and becomes a shared language between the team and the business.

Ultimately, the CM becomes not just a control tool but part of a broader competency management system: it connects roles, grades, development, hiring, and compensation. And that reduces stress because the team gains a simple logic: “this is not about punishment — it’s about alignment and growth.”

ACC (Attribute, Component, Capability) is an approach developed by Google for constructing test plans. Attributes are system properties that matter to the user. Components are structural units from the user's perspective. Capabilities are system actions implemented by components to deliver attributes. Within ACC, a system is represented as a matrix where columns correspond to attributes, rows to components, and cells contain capabilities. For each capability, the risk of failure is assessed, enabling optimal allocation of testing resources.

We have extended the classical method by introducing a fourth dimension. Initially, this dimension represented user classes. However, analysis of its application across various systems showed that the fourth dimension can take different forms depending on the project's specifics: user roles, time of day, frequency of use, context of application, or system dependencies. Potentially, even more dimensions may be introduced.

Development is not a duty, but a right.

An Individual Development Plan (IDP) should not be a bureaucratic formality. Every employee has the right to stability, respect, and recognition of their contributions, regardless of their career ambitions. 

A development model is not about growth for the sake of growth, but rather about making informed decisions along your professional growth.

What to do when you are the only E2E QA on a project where hardware, computer vision, machine learning and cloud infrastructure all come together?

In this talk, I will share the story of testing an AI-powered smart camera — a device that uses VLM (Vision Language Models) to describe what is happening in the frame and generate a summary of the day’s events. I will show some funny moments when the model can describe your cat as “a small dog”, explain why, occasionally, you have to be released without any testing. I will also discuss the methods that help to cover the full E2E testing of a complex product alone.

The main insight of the talk is to demonstrate how the role of a “little man” at the end of the production chain turns into a position of a person with a comprehensive view of the product — a person who becomes the link between teams. Join me for a real-life case study, funny examples of VLM errors, and practical tips on testing smart devices!

In this talk, we will explore why a RAG (Retrieval-Augmented Generation) approach and a local LLM are needed, and how they help build an effective knowledge management system. Step by step, we will walk through the implementation journey — from data preparation to a fully functioning system — with a focus on architecture, quality testing, and performance.

We will share the key challenges we faced and the solutions that proved effective in practice. We will demonstrate the results achieved and the impact on the team, as well as outline our plans for further development. The talk will conclude with insights and practical advice for those who are just starting to work with RAG and local LLMs.

The talk focuses on typical situations where a manager’s behaviour may seem strange or illogical to the team. Using seven common actions as examples, we will explore what employees actually see and what challenges the manager is trying to solve at that moment.

In 2026, the QA learning landscape is flooded with advice — and even more conflicting opinions. That’s why we’re bringing together experts from diverse backgrounds to understand what truly works in practice. We will discuss which learning formats lead to sustainable progress, why some trajectories “take off” while others do not, and how AI tools and market expectations influence these outcomes. In the end, we will outline clear reference points: how to build an educational experience that stays with you long term and helps you move forward with confidence.

How can quality be maintained when regression is growing, automation cannot keep up with business, and urgent tasks are disrupting processes? Would it be possible to reduce the workload of QA without losing control over risks? 

This talk introduces the “Turbulent Testing” strategy – a systematic approach to quality management under unstable workloads. Instead of a one-size-fits-all process, it proposes a context-adaptive model where testing depth is determined by the criticality and risk of the task. 

We will discuss practical implementation mechanisms, task categorisation examples, dynamic Quality Gates, and the impact of this strategy on decision transparency, business trust, and key product metrics.

How to ask a question so that it is understood instantly, and the answer turns out to be exactly what you need to know?

In our workshop, we’ll cover the art of effective questioning and communication between testers, analysts, and developers.

You will see:

• What makes a question high quality: structure, context, objective, and expected outcome.
• Techniques for clarifying requirements through questions: what questions to ask at different stages of the development cycle.
• How to avoid common traps: ambiguity, assumptions, and information overload.
• Methods for rapid answer validation: how to check completeness, usefulness, and applicability of the information obtained.
• The role of questions in reducing workarounds and quality degradation.
• Practical exercises: formulating a set of questions for specific scenarios, learning to get the right answers quickly, and saving the team’s time.

And, of course, we’ll answer the main question — why should tester even ask questions in the first place?

Imagine a team working with an off-the-shelf solution, more than 15 services, and around 100 SQL integrations. And that is just one “box”. There may be two, three, or even more.

How to select test data for regression testing between systems and boxes? What rules should be used to choose the test data? What tools should be used?

AI? 

We have what we need for our task, so how do we solve the main pain point? We need to reduce the manual process of selecting test data. This requires introducing new tools, training, and process setup.

In this talk, I will share my experience and practical examples.

Teams are increasingly using AI to generate code, yet service tests are still written manually — painfully and usually at the very last moment. There are some innovations, but no established approaches: tests either fail to compile or simply don’t work. We set out to fix this.

We built a process where developers define specs, testers refine the requirements, and AI turns them into executable test scenarios. Clear rules, templates, a validation layer, and auto-generated documentation make it possible to scale automation with almost no manual routine.

I’ll show how we implemented SDD (Spec-Driven Development) so that AI generates scenarios that actually run, how we combined code generation with SDD to reduce context load, and which techniques help solve common problems.

Every QA professional has heard of security testing, but most consider it the job of specialised professionals — penetration testers. But what if a regular tester can and should contribute to product security?

In this talk, I'll demonstrate how a functional tester without deep security expertise can identify real vulnerabilities using basic principles and common mistakes. 

Using examples from a real project, I'll examine key vulnerability classes from the OWASP Top 10 — from Broken Access Control to SSRF —and show how they can be identified through simple but systematic checks.

You'll learn how to introduce “security hygiene” into the daily work of a QA team, and why even minimal efforts can prevent serious incidents.

This talk is based on practical experience: over the course of several months, a team of testers identified more than 15 vulnerabilities without specialised tools or access to the internal codebase.

So, we have a large project and a lot of good things have done. 

And we have a task to integrate AI into our test automation — and into testing in general.

There's no particular desire, yet the task exists. 

Formally buying out the project isn't our way.

So, we'll try to improve our processes with the help of AI without breaking the current processes or turning the project iinto a dumping ground of poorly connected, AI-generated code.

This talk explores how to build a QA strategy on a project using the Hypothesis Map approach.
We will go through the core principles of this method, look at quick practical examples, and see how the map helps connect quality goals with specific metrics, hypotheses, and team tasks. Participants will learn how to turn abstract quality expectations into measurable steps and build a strategy that actually works.

This talk focuses on using the open-source geographic information system QGIS (Quantum Geographic Information System) for visualisation and comprehensive testing of web services that work with spatial data. 

I will begin with a brief introduction to the basics: what spatial data is, what coordinate reference systems (CRS) exist, and why they are important for correct visualisation of spatial data. 

You will learn about the key role of the OGC (Open Geospatial Consortium) in standardising geospatial data protocols. We will look at popular protocols and the common philosophy behind their testing, and I will demonstrate in practice how to test the WFS (Web Feature Service) protocol using QGIS.

The talk will be especially useful for GIS engineers, developers, and testers who want to master a powerful tool for ensuring the quality of geospatial data and services.

Product growth often outpaces resources. When features multiply but the team remains static, traditional QA approaches fail.

I will share how Yandex Eats optimized its release process to overcome this deficit. We moved from chaos to a structured system using:

• Processes: Replacing 100% regression coverage with smart test segmentation ("packs") to test less but uncover more.
• Tooling: Reducing routine burdens through product documentation, release calendars, and task bots.
• Automation: How we trained bots to automatically assemble regression packs based on changes.

A practical guide for QA professionals scaling operations under resource constraints.

Do you know what to do if your company starts using vibe-coding in projects?

Are you ready?

As part of the QAIshnitsa activity, we invite you to explore approaches and tools for ensuring the quality of applications built with LLMs.

We encourage you to team up and find the necessary expertise among conference participants. Were you short of an experienced specialist in a particular field? Put a call-out in the conference chat — someone will definitely step in to help.

What participants should bring:

• a laptop with Android Studio installed (we’ll help you set it up)
• your favourite LLM (or willingness to buy one)
• feistiness for vibe-testing!
• a team of like-minded people — or the courage to go solo.

In this talk, I will share our experience of implementing a testing pyramid for a mobile application built on a microservices-based BDUI architecture. I will discuss how it significantly reduced repetitive manual work for QA engineers and enabled us to deliver releases every day.

When stepping into a QA Lead or Head of QA role, it is often unclear how to act — and many people end up choosing one of two extremes. Either they continue working as before: micromanagement, hands-on work as used to do, to be the solver for everyone, or they delegate everything to the team and step back completely. In both cases, this eventually leads to chaos.

Based on my own experience of going through these extremes, I came to a systemic approach as a way of managing people and teams.