Skip to main content
Web // QA

Tests: because 'works on my machine' isn't a release strategy.

We add the automated tests that let your team ship on Friday without flinching: unit, integration, end-to-end, accessibility, and performance checks in CI.

anvexisstack.com/web/qa-test-automation
Layers
Unit · API · E2E
Tools
Pytest · Playwright · Vitest
Where
Every pull request

Test the risky paths first, run everything on every pull request, keep tests fast.

The testing pyramid, practically

LayerWhat it checksSpeed
UnitFunctions and business rulesMilliseconds
IntegrationDatabase, APIs, Odoo modelsSeconds
End-to-endCritical user journeys in a browserMinutes
Non-functionalAccessibility, performance, security scansVaries

An end-to-end test for the path that pays the bills

e2e/checkout.spec.tstypescript
test("customer can place an order", async ({ page }) => {
  await page.goto("/shop");
  await page.getByRole("button", { name: "Add Ergonomic Chair" }).click();
  await page.getByRole("link", { name: "Checkout" }).click();
  await page.getByLabel("Email").fill("qa@example.com");
  await page.getByRole("button", { name: "Place order" }).click();
  await expect(page.getByText("Order confirmed")).toBeVisible();
});

Why automated testing pays off

Every release carries a question: did this change break something that used to work? Without automated tests, the only answer is manual clicking, which is slow, incomplete, and skipped when deadlines are tight. Bugs then reach users, and teams become afraid to change code.

Automated tests answer that question in minutes on every change. Unit tests check individual functions, integration tests check that components work together, and end-to-end tests check the journeys users care about most, such as signing up, checking out, or posting an invoice.

We build test suites that are fast, reliable, and focused on risk. A small set of trustworthy tests on critical paths is worth more than thousands of flaky ones nobody believes.

Test types and their roles

TypeChecksSpeed
UnitIndividual functions and componentsMilliseconds
IntegrationServices, database, and APIs togetherSeconds
End-to-endComplete user journeys in a real browserSeconds to minutes
Visual regressionUnexpected changes in appearanceSeconds
Performance and loadSpeed and capacity under realistic loadMinutes
AccessibilityAutomated WCAG checksSeconds

Tools we use

Playwright

Reliable end-to-end tests across Chromium, Firefox, and WebKit.

Unit and integration frameworks

Vitest, Jest, pytest, and Odoo's test framework, matched to your stack.

Load testing

k6 or Locust scenarios based on real traffic patterns.

CI integration

Tests run on every pull request with clear, fast feedback.

How we introduce test automation

  1. Step 01

    Risk map

    Week 1

    Identify the journeys and code where bugs cost the most.

  2. Step 02

    Foundations

    Week 1–2

    Set up frameworks, test data, and CI integration.

  3. Step 03

    Critical paths

    Week 2–4

    Write end-to-end tests for the most important journeys.

  4. Step 04

    Broaden

    Week 4+

    Add unit and integration tests where risk and change are highest.

  5. Step 05

    Maintain

    Ongoing

    Keep tests fast and fix flakiness as part of normal work.

Scope at a glance

Included

  • Test strategy and frameworks
  • Automated tests for critical paths
  • CI integration and reporting

Not included

  • Exhaustive coverage of every line
  • Manual regression teams

Common pitfalls we help you avoid

The first pitfall is flaky tests. Tests that fail randomly teach teams to ignore failures, so we fix or quarantine flaky tests immediately and design for stable test data.

The second is testing implementation details. Tests tied to internal structure break with every refactor; tests based on behavior survive change.

The third is slow suites. When tests take an hour, developers stop running them, so we keep the main suite fast and run heavier checks separately.

What we measure

MeasureWhy it matters
Critical path coverageShare of key journeys under test
Suite durationHow fast feedback arrives
Flaky test rateHow trustworthy failures are
Escaped defectsBugs found by users instead of tests

Who does what

We handle

  • Test strategy, frameworks, and initial suites
  • CI integration and reporting
  • Training developers to extend tests

Your team handles

  • Agreeing priorities and critical journeys
  • Writing tests for new features
  • Fixing defects the tests find

A worked example

Consider an e-commerce team that manually checks checkout before each release and still ships the occasional broken payment flow. End-to-end tests now cover browsing, cart, checkout with test payments, and order confirmation on every pull request.

A failing test blocks the merge, the developer sees exactly which step broke, and releases stop depending on someone remembering to click through.

What success looks like

Success is a team that changes code confidently, knowing that critical journeys are checked automatically on every change and that a failing test means a real problem.

Where to start testing

If your problem isStart with
Releases break critical journeysEnd-to-end tests on those journeys
Logic bugs in calculationsUnit tests on the calculation code
Integrations fail silentlyIntegration and contract tests
The site slows under loadLoad tests on key endpoints
Accessibility complaintsAutomated accessibility checks in CI

Myths we hear

Myth: Automated tests replace manual testing.

Reality: They replace repetitive regression checks. Exploratory testing by people still finds issues automation misses.

Myth: 100% coverage means no bugs.

Reality: Coverage shows which code runs during tests, not whether behavior is correct. Focus on meaningful assertions.

Myth: Testing slows development down.

Reality: Good tests speed teams up by catching problems early and making changes safe.

Before you start

  • A list of critical user journeys
  • A test environment with realistic data
  • CI where tests can run

Questions to ask any provider

  • Which user journeys will be covered first?
  • How long will the test suite take to run?
  • How are flaky tests handled?
  • Who will maintain the tests after handover?

Keeping it maintainable

Tests follow the same standards as production code: reviewed, readable, and organized by user journey. Shared helpers keep them short, and a weekly look at slow or flaky tests stops the suite from decaying as the product grows.

Shape of a healthy test suite

Ham Vocke's practical test pyramid gives the shape we aim for: lots of small and fast unit tests, a moderate number of coarser-grained tests, and very few high-level end-to-end testsSource [1]. End-to-end tests are valuable but slow and brittle, so we keep them for the journeys that matter most, such as checkout or invoicing.

To know whether testing is working, we track DORA's change fail rate, the share of deployments needing immediate intervention, and failed deployment recovery timeSource [2]. Both should fall as coverage improves on the risky paths.

Frequently asked questions

Where do we start with no tests?
With end-to-end tests on the few journeys that would hurt most if broken, then unit tests on new code.
Can you test Odoo customizations?
Yes, with Odoo's test framework for models and tours for UI flows.
How do you keep tests from being flaky?
Stable selectors, controlled test data, and no arbitrary sleeps.
Do you do manual QA?
Yes, for exploratory testing and release candidates, alongside automation.
Can tests run in our CI?
Yes, in GitHub Actions, GitLab CI, or your existing pipeline.
Can you add tests to an old codebase?
Yes. We start with end-to-end tests on critical journeys, which protect behavior without needing to restructure code first.
Do you test Odoo customizations?
Yes, with Odoo's test framework for modules and Playwright for user journeys.
How much test coverage do we need?
Coverage numbers matter less than covering critical paths and risky code. We focus there first.
Can tests run against staging?
Yes. End-to-end and smoke tests can run against staging or production-like environments after each deploy.
Who maintains the tests?
Your developers, ideally, as part of normal work. We set up the patterns and train the team.
Can tests run on mobile browsers?
Yes. Playwright emulates mobile devices, and real-device testing services can be added for critical flows.
How do you handle test data?
With seeded, repeatable datasets and cleanup after each run, so tests don't depend on each other.
Do you test APIs as well as screens?
Yes. API tests are faster and more stable than browser tests for checking business logic.
Do you provide test reports?
Yes. Each CI run produces a report with failures, screenshots, and traces for end-to-end tests.
Can you test third-party integrations?
Yes, using sandbox environments or mocked services so tests stay reliable and free of side effects.
Can you test performance as part of CI?
Yes. Lightweight performance checks, such as page-load budgets, can run on each change, with full load tests scheduled separately.
How quickly can we see value?
Usually within the first weeks, once tests cover the most important journeys and run on every pull request.
How many end-to-end tests do we need?
Few: enough to cover the critical journeys. Most coverage should come from fast unit and integration testsSource [1].
How do we know test automation is worth it?
Watch change fail rate and recovery time fall as tests cover the risky pathsSource [2].

Sources

  1. [1]The Practical Test Pyramid (opens in a new tab)Ham Vocke, martinfowler.com, 26 February 2018
  2. [2]DORA's software delivery performance metrics (opens in a new tab)DORA, updated 5 January 2026