Leading the frontend of a large, aging Angular platform — stabilising a codebase carrying years of stacked technical debt, closing the version gap release by release, and setting the engineering standards and review culture it never had. The platform serves internal teams across sales, logistics and finance, so every regression carries a real operational cost. I put together a phased upgrade path that moved the app from Angular 11 to 16 without a big-bang rewrite. Alongside the migration I built a proper code review culture from nothing and mentored three junior engineers into the codebase. Tailwind, consistent formatting and a real PR workflow followed naturally once the foundation was stable.
Four years owning the full stack of a mapping platform — continuous delivery against live, real-time APIs. The app tracks assets across a national network, so map performance and update latency are constantly under scrutiny. I rebuilt large parts of the UI and backend services as the product grew from a single dashboard into a full operations suite. Real-time notifications, live redesigns and new integrations shipped continuously alongside day-to-day maintenance. Along the way I introduced a shared design system with accessibility-first patterns that the rest of the team still builds on.
A cert-prep platform for cybersecurity exams — practice tests, spaced repetition, progress dashboards. I lead development end to end, from the Postgres schema to the Stripe billing flow, with Artur contributing on the engineering side. Questions and scheduling live as data, so the question bank grows without touching the codebase. Nearly 1,800 questions across 20+ exams are already live in open beta. It has been running continuously since 2025 with no dedicated backend, frontend or DevOps team — just the two of us keeping it online.
MSc thesis — a browser extension and desktop app that measures UI/UX performance, capturing eye-tracker data alongside DOM inputs and events to generate detailed usability reports. Built with a research partner across two platforms, web and desktop, so sessions can be captured wherever a participant actually works. The measurement approach draws on Tom Tullis and Bill Albert's usability metrics research. It's set to open source once the last integrations land.
Started as the friend I built side projects with; he went deep on security while I stayed on the product side. Years of shipping together later, we are building a cybersecurity education platform — he sets the curriculum and the threat models, I build the thing people actually click. The split works because neither of us has to explain our half twice.
Manages the technical and business requirements for the e-commerce platform we are working on. He carries responsibility for the whole process; I bring the innovation to the core Angular application. He provides precise functionality requirements, which I consolidate into the frontend solutions.
Runs the startup I joined when I was starting out, to get real production experience rather than a title. I never left. Four years later I am still on the project part-time alongside full-time work — the arrangement has outlasted every reason I originally had for it.
Built a usability testing tool with me for our master's thesis — his backend, my frontend, one deadline neither of us could move. The subject matter stuck: writing software whose whole purpose is measuring how people struggle with software changes how you build everything after it.
Owns a feature end to end — schema, service, and the interface that ships it. No handoff between specialists means no gap where a feature's intent gets lost in translation.
Turns a roadmap into shipped tickets and a written record a team can run without me in the room. The record is the point — decisions ought to outlive the meeting they were made in.
Wires the pipeline that gets a container from commit to production without a manual step in between. If it isn't automated, it isn't the process — it's a step waiting to be forgotten.
Builds the test net — unit through e2e — that lets a team ship without re-checking every screen by hand. Coverage is a byproduct; the actual goal is a green run nobody has to think about.
Sets the tokens and motion language a UI runs on, then holds the line on craft through implementation. A system is only as good as the discipline to actually use it everywhere.
01DiscussScope and constraints, talked through first. Left unsupervised, LLMs drift — confident and wrong — so a real conversation sets the boundaries before any model touches the keyboard.
02PlanThe conversation closes into a written spec with a goal-backward check. This is the first gate: nothing downstream opens until the plan is settled.
03ExecuteClaude and Codex draft it in parallel, then get graded against each other — never taken at their word. The disagreement between two drafts is where the bugs surface.
04TestType-checks and tests run on every change. A green build is the floor, not the goal — proof nothing obvious broke, not that the work is right.
05Code ReviewEvery diff is read line by line before it's trusted. Nothing reaches the main branch on a machine's say-so — the last gate is human.
06ShipAtomic commits, merged only once every gate holds. Skipping a step never saves time — it just moves the failure downstream, where it costs more.
