Nordic Testing Days 2026

Writing mobile tests with Appium can be challenging. Many of us have dealt with unstable selectors, differences between Android and iOS, or slow progress. What if we could use artificial intelligence with Appium? And what exactly is Mobile MCP?

Tutorial Overview

This tutorial is for anyone interested in starting mobile testing with a modern approach. We’ll use Python throughout. Together, we will build an end-to-end framework where AI supports us from the beginning. We will see how tools like Mobile MCP can find elements without needing static IDs or XPath.

We’ll focus on building full end-to-end scenarios. We’ll test whether self-healing really works or is just hype. We’ll also look at where AI can speed up our work, and where we still need the Appium Inspector.

Note: This is a hands-on tutorial and requires some preparation upfront. We’ll send you detailed instructions in advance.


Agenda

1. AI in Appium: We’ll talk about the main challenges in classic mobile testing and what AI can help solve.
2. E2E framework architecture: How to set up a project for AI-powered end-to-end testing, going beyond the basic Page Pattern.
3. What is "Mobile MCP"? We’ll give a practical introduction to the tool and show how it works with Appium.
4. AI vs. Appium Inspector: We’ll see how AI can find elements in an app as they change.
5. Building an E2E Scenario: Step by step, we’ll create a full test path, like logging in, searching, and adding to the cart.
6. Intelligent assertions and self-healing: We’ll see how AI helps check the app’s state and what it does when the UI changes.
7. Results analysis: We’ll look at how AI can help us figure out why an end-to-end test failed.
8. Summary: AI in mobile - revolution or evolution? We’ll finish with a Q&A session.

Performance issues often surface only when it’s too late - after deployment, when real users start to feel the impact. Load testing helps prevent that, but many teams still see it as a complex or time-consuming task. This workshop aims to show how accessible and powerful it can be using k6, an open-source, developer-friendly tool designed for modern performance testing.The session starts with a short introduction to the fundamentals of load testing: what it is, when to use it, and the different test types supported by k6 - average, stress, spike, soak, breakpoint and smoke. Participants will also get a quick overview of how k6 works under the hood and how it integrates into a development workflow.From there, we’ll move into a hands-on, guided session, beginning with a simple GET request and gradually expanding it into a complete load testing project. Each step introduces a new concept: adding thresholds and stages, randomizing requests, implementing assertions, handling errors, and organizing the project using npm and Prettier. We’ll then extend the script with multiple endpoints, visualize live results on the web dashboard, and perform authenticated requests using JWT tokens.Throughout the workshop, I’ll share real-world experiences and lessons learned from conducting load tests on different projects—what to watch out for, common pitfalls, and how to interpret the results effectively.Participants will leave with both the theoretical foundation and practical skills to start creating their own performance testing setup using k6. All examples will be built live, and attendees can follow along on their own laptops. Only basic JavaScript knowledge is required.


Key takeaways:

1. Understand the core principles of load testing and how to apply them effectively using k6 in real-world scenarios.
2. Gain hands-on experience building and running performance tests step by step—from a simple request to a full, maintainable testing suite.
3. Learn practical insights and troubleshooting techniques drawn from real project experiences, helping you avoid common pitfalls and get meaningful results faster.

Observability and testing are treated as kind of separate practices in software engineering. Usually in organziation there are testing teams that focus on tests and site reliability teams that monitor applications in production.Testers find bugs before software is released and after the release, when bug occurs, we get that information from SRE teams.What if we could shift the process of monitoring system behaviour a little bit left and combine SRE practices with power of testing?


Key takeaways:

1. How to implement traces, metrics and logs in testing framework.
2. How to set up OpenSource observability backend - Grafana LGTM stack.
3. How to visualize test logs in LokiHow to visualize test metrics in PrometheusHow to visualize test traces in Tempo