I design, build and run systems in production — from the business problem to day-to-day operations.
For 19+ years I've taken technical responsibility for systems that have to work every single day: architecture, backend, integrations, infrastructure, security and AI applied as part of the engineering.
How I work
It started around 2007, still a teenager, tweaking templates and breaking pages on blogs until I understood what happened behind every line. By 14 it was already an obsession — and more than 19 years later, that same habit of taking things apart to understand them is still my method.
I've lived through nearly every wave of the web: blogs and SEO, servers, PHP and Laravel, modern front-end, Docker, the cloud and now applied AI. Each phase added a layer — structure, performance, operations and finally architecture, which is where the decisions actually carry weight.
Today I'm accountable for whole systems, not snippets of code: I design the architecture, build the backend and the integrations, provision the infrastructure, ship it, monitor it and keep it running. I've delivered multi-tenant SaaS and ERP platforms, real-time systems for thousands of concurrent users, industrial telemetry wired to PLCs and AI systems in production.
A large share of serious work happens inside software that already exists. I know how to step into a legacy codebase, recover the business rules nobody documented and modernise it in stages — without stopping operations and without breaking what already works.
With AI the principle is the usual one: judgment before hype. I use AI as an engineering component and as a multiplier for my own work, always with review, tests and attention to cost, security and the real limits of the models.
In the end, my value goes beyond writing code: it's solving problems through engineering and owning technical responsibility for whatever goes into production.
The timeline
The phases of the journey, in order — with each era's technologies in plain sight.
2007 First steps on the web. Where it all began: build, break and fix.
HTML · CSS · WordPress · PHP
2010 SEO, traffic & infrastructure. Drive traffic and keep it all up.
indexing · performance · servers
2013 Web engineering. Serious web apps with real business rules.
PHP · Laravel · APIs · multi-tenant
2016 Python expands the technical base. Automation, data and system-to-system integration.
automation · data · integrations
2018 Front-end & mobile. Modern interfaces and store-published apps.
React · Vue · Kotlin · Swift · Flutter
2020 Cloud, DevOps & architecture. Infrastructure as code and accountability for operations.
AWS · Azure · GCP · Docker · Terraform
2023 → now AI inside the engineering. AI as a system component, with tests, cost and limits — since ~2019.
RAG · agents · LLMs in production
Each phase added to the last — it all coexists in today's stack.
I don't hand over the implementation alone: I take the whole cycle and stay accountable for the system once it's live.
Understand the business rules and what actually needs solving.
Set structure, boundaries and trade-offs, with maintenance cost in view.
Build backend, interfaces and automations, with tests and review.
Wire up APIs, data, third-party services and field equipment.
Provision cloud, containers and infrastructure as code.
Ship through automated pipelines, with predictable rollback.
Metrics, logs, alerts and diagnosis when something goes off track.
Maintain, modernise legacy and evolve without breaking what works.
Real-world cases presented through the problem, responsibility and delivery stage.
Some projects are presented anonymously due to contractual confidentiality.
Regulated sectors needed their own management platform without running a separate system per client. I delivered multi-tenant platforms with billing, APIs and third-party integrations.
Responsibility: Multi-tenant architecture, domain modelling and integrations.
Live events and education had to hold thousands of concurrent viewers without losing interaction. I delivered the platform with real-time chat, polls and assessments.
Responsibility: Real-time architecture, backend and ongoing production support.
Distributed teams needed to validate identities, assignments and operational assets, track field journeys and handle anomalies without losing context or traceability. I built an integrated platform from the ground up — web operations centre, API and mobile apps — with on-device authentication, geolocation, operational checks, real-time events and incident response.
Responsibility: Full-cycle architecture and delivery across backend, web operations centre, mobile apps and operational integration.
Administrative and commercial processes relied on manual work spread across applications with no proper integration. I designed an agent architecture able to read interfaces, drive web and desktop systems and coordinate flows with rules, approvals and traceability.
Responsibility: Agent architecture, task orchestration and integration between systems.
Operations had no visibility into what field equipment was doing. I integrated sensors and PLCs over LoRaWAN, MQTT and Modbus and delivered real-time operations dashboards.
Responsibility: End-to-end integration, from field equipment to the operations dashboard.
Managing properties, contracts, billing, maintenance and documents was scattered across processes that never talked to each other. I defined the architecture and the scope of a modular, multi-tenant platform to centralise property operations, financial flows and ecosystem integrations.
Responsibility: Product architecture, domain modelling and scope definition.
Marketplace operations had to track catalogue, stock, pricing, reputation, logistics and finance without relying on scattered controls. I designed an architecture of specialised agents, with responsibility per role, permissions, shared context, human approval, auditability and exception handling.
Responsibility: Multi-agent architecture, integration model for external APIs and action governance.
A digital lending journey had to cut friction without giving up validation, security and traceability. I structured the flow for sign-up, identity verification, document upload, contracting and integrated payments.
Responsibility: Journey architecture, integrations and security controls.
Too many documents for manual search, in a context where a made-up answer was unacceptable. I built the ingestion, structuring and semantic search pipelines with embeddings.
Responsibility: Ingestion pipeline, indexing and answer-quality control.
Environments assembled by hand and failures found by users before the team. I standardised the infrastructure with Terraform and containers and put monitoring and error alerting into production.
Responsibility: Infrastructure as code, deployment pipeline and observability.
I design and ship systems with RAG, agents, document ingestion, embeddings and vector databases, automations and real-time voice — wired into the systems that already exist, not as a standalone demo. I treat AI like any other engineering component: model evaluation, tests, cost and latency control, explicit limits and failure modes, human review wherever a mistake is expensive, data security and observability in production. I also use AI in my own process to produce more, without giving up review, tests and technical responsibility for what goes live.
Tooling follows the architectural decision, not the other way around. This is the base I use to sustain it in production.
Got your message — I'll reply soon to the email you provided. If it's urgent, ping me on WhatsApp.
Reply goes to