Services · QA & Software Testing
We build the testing layer your product has been missing: a written test strategy, exploratory sessions by people who think like your users, automated suites that run on every commit, and clear release readiness criteria.
You own the code and IP Weekly demos Reply within one business day
build-orchestrator
mainsrc/
queue.ts
pool.ts
retry.ts
types.ts
index.ts
1
2
3
4
5
6
7
8
export interface BuildJob {
repo: string;
region: "ca-west-1";
}
export async function queue(
job: BuildJob,
): Promise<Run> {
return await pool.add(job);
212
Tests passed
0
Type errors
1.4s
Build time
Watching src/ — optimised rebuild on save
OlDevs is a full-stack technology studio in Vancouver, British Columbia that provides quality assurance and software testing for web, mobile and back end products.Our QA work covers test strategy, manual exploratory testing, automated unit, integration and end to end suites using tools such as Vitest and Playwright, cross browser and device coverage, accessibility testing to WCAG 2.2 AA, and performance and load testing. We run regression suites in continuous integration so every commit is checked, and we triage bugs by severity against agreed release readiness criteria. Teams that have never had formal QA can start with an audit of an existing product, which is often the first step before a redesign.
Key facts
Quality assurance and software testing
We write down what gets tested, at which layer, and why. The plan names the risky areas of your product, sets the balance between unit, integration and end to end tests, defines your test data and environments, and gives everyone a shared definition of done.
Scripted cases catch what you expected. Exploratory sessions catch the rest. Our testers work through charters against real workflows, on real devices, and record reproducible steps, screenshots and console output for anything that breaks.
We build tests at the layer that gives the best return: fast unit tests with Vitest or Jest, integration tests around your API and database, and end to end journeys in Playwright or Cypress that drive the real browser the way a customer would.
Coverage across current versions of Chrome, Safari, Firefox and Edge, plus iOS and Android handsets and tablets at the breakpoints that matter to your traffic. We test on real devices and device clouds, not only emulators, and we report what actually broke where.
Automated scanning with axe-core and Lighthouse finds the mechanical failures. A manual pass covers keyboard order, focus visibility, headings, labels, contrast and screen reader output in VoiceOver and NVDA, since most real barriers never show up in a scan.
We profile page and API performance, run load and soak tests with tools such as k6 or Apache JMeter to find where the system bends, and coordinate security testing and penetration test remediation with your chosen assessor or internal team.
Process
Audit and risk review
We work through the current product, read the code and the incident history, list the highest risk areas, and report what is untested today. This is often where a pre redesign engagement starts.
Test strategy
A written plan: layers, tools, environments, test data, device and browser matrix, accessibility standard, and the release readiness criteria we will hold the build to.
Build the suites
We write the automated tests, wire them into your pipeline, and run the first full manual and exploratory pass so you get a real baseline of the product's current state.
Triage and fix cycle
Findings are logged, triaged by severity and priority, and worked through with your developers or ours. You see a demo of the fixes every week.
Release and ongoing regression
We check the build against the readiness criteria, support the release, then keep the regression suite maintained as the product changes so coverage does not quietly rot.
How we work
A high coverage number proves very little. We rank features by what it would cost you if they failed, then spend testing effort where the money and the reputation actually sit.
Regression suites live in your continuous integration pipeline on GitHub Actions, GitLab CI or a similar runner, so a broken build is caught in minutes rather than during a release window.
Every report carries environment, build, steps to reproduce, expected versus actual behaviour, severity and priority. No ticket that just says it is broken.
How badly something behaves and how urgently it should be fixed are two different questions. Splitting them keeps triage honest and stops cosmetic issues from blocking a release.
Before a launch we agree the criteria: which suites must pass, which severities are blockers, what the rollback plan is, and who signs off. The decision to ship stops being a debate.
A test that fails at random teaches the team to ignore red builds. We quarantine flaky tests, find the real cause, and keep the suite trustworthy enough that people act on it.
Who it's for
Internal platforms and customer facing products where a defect reaches thousands of people at once. We add QA governance, audit trails and accessibility evidence that procurement and compliance teams can review.
Member portals, registration systems and public services that must meet WCAG 2.2 AA and stay dependable during peak periods. We document coverage and test outcomes in a form you can hand to a stakeholder.
Multi location sites, ordering flows and franchisee portals where one regression repeats across every location. Shared regression suites protect the template and catch the differences between locations.
Teams shipping quickly who have never had formal QA. We start light with the highest risk journeys, get a regression suite running in CI, and grow the coverage as the product and the team grow.
Weekly
Working demo cadence
1 day
Reply to every enquiry
2014
Testing software since
FAQ
Start with an audit of the product you already have. We work through the main journeys manually, run automated accessibility and performance scans, read the code and the incident history, then give you a ranked list of risks and a test strategy. From there you can decide how much automation is worth building and in what order.
Yes, and it is one of the most useful things you can do. Testing the current product tells you which behaviours users depend on, which defects you must not carry forward, and what your accessibility and performance baseline actually is. That evidence shapes the redesign brief and gives you something concrete to measure the new build against.
It depends on your stack. We commonly use Vitest or Jest for unit tests, Playwright or Cypress for end to end journeys, axe-core and Lighthouse for accessibility and performance scanning, and k6 or Apache JMeter for load testing. Suites run in continuous integration on GitHub Actions, GitLab CI or your existing runner. Tool choices are current at the time of writing.
Yes. Most of our QA work is on code written by someone else, including products from a previous agency or an in house team. We read the codebase, map the journeys, and write tests around the behaviour as it stands today so you have a safety net before anyone changes it.
Either arrangement works. Some clients bring us in as an independent QA function beside their own engineers, so the people testing are not the people who wrote the code. Others ask us to build and fix. You get one accountable team and one point of contact rather than a rotating cast.
We agree the criteria before the release, not during it. That usually covers which automated suites must pass, which bug severities count as blockers, the accessibility standard the build must meet, performance thresholds, the rollback plan, and who signs off. If the criteria are not met we say so plainly and explain the risk.
We coordinate it rather than presenting ourselves as a penetration testing firm. We cover the practical ground in our own work: dependency and vulnerability scanning, authentication and authorisation checks, input validation and secure configuration review. For a formal penetration test we work with your assessor and manage the remediation.
Let’s connect
Tell us what you’re building. We’ll reply within one business day with next steps and a tailored quote — no obligation.