Experience
Twenty years of it, folded away. Open what you need.
Lead AI engineering and transformation at Miquido: take enterprises from AI experiments to AI that runs in production, set the engineering standards delivery teams work to, and build the internal capability to operate it. Work the same problem from both ends — with boards on where AI creates real value, with engineering teams on what it takes to run it responsibly.
Partner with business stakeholders and clients to translate goals into a clear solution direction, scope and measurable outcomes. Facilitate discovery: clarify ambiguous requirements, align expectations, and turn them into roadmaps, milestones and acceptance criteria.
Led and grew backend teams with a strong focus on people development, ownership and sustainable delivery practices. Improved delivery predictability by setting clear priorities, reducing work-in-progress, and aligning execution with business goals.
Owned technical direction for backend and integration-heavy systems: architecture decisions, system boundaries and maintainability standards. Led technical planning and execution end to end.
Senior backend engineering and integration work across multiple client domains.
Gameplay systems and feature logic in C#.
Technical lead on game projects.
Main originator of founding the Software Engineering Department. Organised the department and managed a team of 12 programmers while working as both programmer and project manager.
C++ development across products and internal systems.
End-user support and internal IT infrastructure.
Where it started: C++ applications and internal tools supporting operational workflows.
Team growth, mentoring, hiring, 1:1 coaching.
Business goals into technical scope, milestones and acceptance criteria.
Product, engineering, clients, compliance and security.
Pragmatic decision-making under incomplete information.
Value and risk trade-offs, delivery predictability.
Ownership, accountability, psychological safety.
TypeScript/JavaScript, Go, Python, C++.
Supabase — Edge Functions, Auth, Postgres, Realtime, Storage, Row Level Security; backend-as-a-service architecture patterns.
Distributed systems, service boundaries, modular architecture, maintainability.
REST and GraphQL APIs, external and internal system integrations, contract-first collaboration.
SQL/NoSQL, Redis, S3-compatible object storage, schema evolution.
RabbitMQ, AWS SQS, queue-based workflows.
AWS, GCP, Terraform, CI/CD with GitHub Actions and GitLab CI.
Production readiness, incident handling, rollout strategy, observability mindset.
Design reviews, code reviews, definition of done, technical planning.
Technical direction, execution planning, cross-team coordination, long-term ownership.
Selecting high-value use cases, drawing the boundary between AI and deterministic logic, designing reliable production workflows.
Retrieval design, indexing strategy, chunking, metadata, context optimisation, answer-quality tuning.
Tool and function calling, multi-step orchestration, integration with internal APIs and business processes.
System prompts, task decomposition, output schemas, robust failure handling.
Test scenarios, golden datasets, regression checks, hallucination risk reduction, human-in-the-loop review.
Guardrails, data sensitivity awareness, access boundaries, responsible rollout strategy.
Model selection trade-offs across quality, latency and cost; monitoring and iteration loops.
Professional use of Codex and vibe-coding workflows for faster implementation, refactoring, debugging and documentation.
Practical AI adoption in product development, including real delivery constraints and implementation lessons.
How to implement agentic LLM workflows — tool calling, orchestration, evaluation — while keeping deterministic boundaries, safety and measurable output quality.
A practical model for evaluation, guardrails and human-in-the-loop checks to make AI features dependable in real products.
Design choices for chunking, retrieval, metadata and iteration loops that improve answer quality and reduce hallucination risk.
A framework for turning ambiguous requirements into clear architecture direction, milestones, acceptance criteria and realistic implementation plans.
How to lead discovery workshops, define scope, and create milestone-driven roadmaps with measurable outcomes.
Techniques for communicating trade-offs to product, engineering and non-technical stakeholders to keep projects on track.
How to design modular backend architectures, integration contracts and quality gates that reduce long-term complexity and production risk.
A framework for balancing speed, maintainability and risk when making architecture and platform choices.
How to run effective design reviews that catch architectural risks early and align teams on implementation standards.
Practical patterns for combining TypeScript/Go backend engineering with Codex-style acceleration, while preserving code quality, review standards and operational reliability.
How to design REST and GraphQL contracts, versioning strategy and validation rules that keep cross-team integrations predictable.
A pragmatic guide to incident handling, rollout strategies and observability habits that improve production stability.
Lessons from managing a backend organisation, improving delivery predictability, and building a culture of trust, accountability and sustainable performance.
Practical approaches to 1:1s, feedback, career planning and performance alignment without creating process overhead.
Methods for controlling work-in-progress, setting clear priorities and improving execution focus across multiple teams.
Self-published book on using LLMs in software development. Available free of charge.
Awarded for contribution to the judo community.