I build the parts of a product nobody sees: the queues, APIs and data flows that have to keep running.

The hard part of a chat box on a portfolio is not answering questions about my CV. It is declining everything else: writing a visitor’s code, judging their hiring process, inventing experience I do not have.

Everything it knows is my CV and these write-ups, assembled at build time from the same files this page renders, so its answers cannot drift from what you are reading. The whole corpus is about two thousand tokens, small enough to hand over whole, so there is no retrieval step and no vector store to keep in sync. It answers from a Cloudflare Pages Function on a model binding, so no API key reaches the browser, under caps on message length, turn count and reply length.

Visitor text is treated as a question, never as an instruction. The scope rule is written as what the assistant is for rather than as a list of banned topics, because a blocklist invites people to go looking for the gap.

ASK A QUESTION

A mailbox that no longer exists and a mail server having a bad minute fail the same way at the transport level. Treat them identically and permanent rejections ride the full backoff schedule, crowding out the transient failures a retry would actually fix.

I designed a retry strategy for the mail queue that reads the SMTP response and splits the two: permanent rejections stop after the first attempt and are recorded, transient ones back off and try again. Not much code, and it decides whether the retry queue is reporting problems worth acting on or just talking to itself.

A phishing campaign produces a lot of events. What a security officer needs from it is one document they can forward to management without editing it first.

I led that summary export end to end: scoping with product, designing the aggregation, building the rendering pipeline, and taking it through release. Deciding what a reader who was never in the tool needs to see is most of the work. The PDF is the easy half.

Support could tell that something had broken for a customer, but not what, so every question became an engineering interrupt.

I built dashboards over the platform’s logs and metrics so the team could trace a failed action themselves: which service, which error, and when. Engineering stopped being the first stop for triage.

Shipment data passes through many hands, and every stage has a deadline.

I built modular backend components handling that flow. A good share of the work was on the database side, reworking queries and access patterns where the latency was showing up in daily operations rather than in a profiler. Shipped in a Scrum team on a frequent release cadence, with QA involved early enough to catch edge cases before customers did.

Older Java-based internal services held data the newer web platforms needed, and moving it between them was a manual job.

I wrote Python services to carry that data across, and integrated third-party APIs into the platforms themselves. Routine integration work that took a recurring manual step out of the week.

Extraction pipelines against public web sources, handling the usual realities: pagination, rate limits, markup that changes without warning, and pages that only render under a real browser.

Collected data landed in a schema designed for querying rather than just storing, so the people who asked for it could use it without a second pass.