Automation architecture
Frontend, API, and integration automation built as a real codebase, with the structure and review standards that implies.
It keeps working as the product changes, and when something fails you can tell why.
Software engineer · Quality engineering and development
I build the systems that tell a team whether their software actually works.
I don’t start by asking whether something is possible. I start by finding a way.
Close to twenty years building test platforms, CI pipelines, and developer tools. I come at quality as a software engineer, and lately a good part of my time goes into working out where AI genuinely helps.
Software engineering is the foundation.Quality is the specialization.
What I build
Quality systems built for how engineering actually works.
Automation, delivery infrastructure, and quality signals are really one system, so I work on them together. What a team needs is a clear answer sooner, and that rarely comes from running more tests.
Quality engineering
Quality work that starts at design review and risk analysis and carries all the way through to what CI reports on a Friday afternoon.
Release decisions get easier, because the risks surface early and people believe the results.
Developer productivity
CI feedback, failure diagnostics, and internal tools that shorten the gap between pushing a change and knowing whether it was a good one.
Engineers stop treating the test suite as background noise they have to work around.
Applied artificial intelligence
LLMs applied where interpretation is the hard part: classifying failures, summarizing an investigation, reading a design. Always with a schema and a human check.
The model helps read the evidence. It never gets to decide what the evidence is.
Technical leadership
Code and architecture review, mentoring, and being the person who stays calm when a decision is genuinely hard.
The system gets better, and so does the team’s ability to keep it that way.
Selected engineering work
What I’ve built, and why it was built that way.
Each one covers the problem, the decisions I made, and what the system gave back to the people using it. Anything confidential has been left out or generalized.
Product engineering
Booking & Scheduling Platform
A Go and React scheduling product, from the booking lifecycle down to the deploy pipeline. Built and shipped solo.
In active development
Applied AI demonstrator
Bilingual Document Assistant
A retrieval-augmented assistant that answers questions in French or English about a long French agreement, and cites the article it used.
Working demonstrator
Developer productivity platform
Test Automation Reporting Platform
A Go and PostgreSQL service that turns scattered CI test runs into one queryable record an engineer can read.
Built · evolving
Sanitized enterprise case study
Enterprise Quality Engineering
Automation architecture, cloud test infrastructure, CI stability, and coaching across several products at once.
Completed work · sanitized
Quality practice transformation
API Automation & CI Transformation
An API automation framework and a regression strategy that put the results in front of developers, in CI.
Completed professional work
Applied AI
Use AI where interpretation helps. Keep facts deterministic.
I treat LLMs as engineering tools and judge them the same way. They earn their place on classification, summarizing, and design review, provided the inputs and the review path are pinned down first.
AI doesn’t replace test logic, and it doesn’t take responsibility for a release. Model size, context limits, privacy, latency, and cost are design constraints like any others.
Deterministic systems
Establish the facts
Tests, parsers, rules, and telemetry give the same answer every time you run them. That output is the record.
- Repeatable
- Traceable to source
- Cheap to re-run
AI-assisted interpretation
Find useful patterns
A model can group failures, summarize a long investigation, or suggest where to look first. It works from bounded context and returns a schema.
- Probabilistic
- Bounded context
- Structured output
Human validation
Make the decision
An engineer checks the evidence, weighs the risk, and ships or holds. The accountability sits here and nowhere else.
- Has the context
- Carries the risk
- Signs it off
Engineering principles
Confidence comes from the quality of the signal.
The ideas I keep coming back to when I’m designing a system or reviewing someone else’s.
Quality is an engineering capability.
It belongs in the design discussion, in the code, in the pipeline, and in whatever happens after release.
Reliable information beats test volume.
A failing test that can’t tell you why is noise with a red icon on it. Good automation makes the next step obvious.
Architecture should improve developer speed.
A well-built test system answers in minutes and doesn’t ask you to hold the whole thing in your head.
Use the right kind of reasoning.
Deterministic code, a language model, and a person are each good at very different things. Match the tool to the part of the problem.
Decisions need evidence and context.
What broke last quarter and what the product actually does should count for more than whatever is fashionable this year.
Technical toolbox
Technology, grouped by the job it does.
Tools only matter in context. This is grouped by the work they do, which is more useful than an alphabetical wall of logos.
Software development
Writing the services, tools, and integrations that hold an automation estate together.
- Python
- Go
- SQL
- Shell
- TypeScript
- REST APIs
- GraphQL
Quality engineering
Getting trustworthy evidence out of every layer of a product.
- PyTest
- Playwright
- Selenium
- API testing
- Integration testing
- System testing
- Regression architecture
- Risk-based strategy
Infrastructure & delivery
Putting feedback where engineers will actually see it.
- Docker
- AWS
- GitHub Actions
- CircleCI
- Jenkins
- CI/CD
- Linux
- Cloud test infrastructure
Data & backend systems
Turning raw execution data into something you can query.
- PostgreSQL
- Relational data
- API services
- Test reporting
- Analytics
- Structured test data
Applied AI
Judging models and workflows on privacy, cost, and whether the output can be checked.
- LLM-assisted development
- Local models
- Prompt design
- Structured outputs
- Model evaluation
- Context management
- Quantization
- Human-in-the-loop
Leadership
Better systems, and a team that understands why they’re better.
- Technical design
- Mentoring
- Code reviews
- Architecture reviews
- Quality strategy
- Risk analysis
- Cross-team collaboration
- Engineering standards
Let’s solve something difficult
If any of this is useful to you, get in touch.
I’m open to roles in quality engineering, automation architecture, and developer productivity, and always happy to talk about applied AI.