Akın Öztorun · Senior Product Engineer
The right architecture doesn't fail silently. Missing connections do. I instrument before I build, fix root causes before I patch, and wire prevention into CI so the same bug can't ship twice. My last funnel handled 400K applications a year; I took it from 39% to 65% by measuring first.
Track record
product teams
system scale
funnel completion
Best fit: product teams in EU time zones that care about contracts, tests, and clear ownership. Teams that treat AI tooling as infrastructure, not autocomplete.
Nine years owning frontend in product teams.
Architecture owner for a Vue 3 / Nuxt platform at a 400K-application-per-year scale. Drove a Nuxt 4 migration to Feature-Sliced Design to enforce clear ownership boundaries. Established a token-driven design system over PrimeVue and introduced structured observability with Mixpanel and Sentry.
Owned an ATS funnel processing 400K applications a year. Took completion from 39% to 65% by instrumenting first: measuring where users dropped, forming hypotheses, shipping targeted fixes, confirming with data. Built the shared UI component library, added Lighthouse CI and SonarQube, and received the Proxify Quality Award 2024.
Primary React/TypeScript owner for client SPAs and dashboards. Moved Lighthouse scores from the 40s to the 90s, making performance regressions visible before they reached users. Built backend utilities with Node.js and AWS Lambda.
What it is like to ship a slice together.
Agree on the API and data shapes before building screens. Generate types, mock early, and keep a simple contract check in CI.
Own one slice end to end, from user goal to contract, UI states, monitoring, and a calm rollout plan.
Linting, tests, code checks, and basic performance checks live in CI so they run on every change, not only before big releases.
Ask precise questions, write short docs, and make trade offs visible so others can decide with you, not after you.
Claude Code runs as a configured system, not a chat window. CLAUDE.md encodes stop rules and architectural constraints. Hooks enforce what CLAUDE.md requests. The model gets routed by task complexity. Every correction becomes a permanent guardrail visible in git history. The loop improves itself.
Architecture Decision Records from production work. The context, the call, the rejected alternatives, and what I'd do differently.
14 ADRs spanning community platforms, a 400K-application ATS, a German legal-tech platform, and agentic tooling. Each one is a real decision under real constraints — incomplete specs, solo ownership, federated teams, production pressure. If you're evaluating me for senior or staff scope, start with the reversals: that's where the signal is.
The ATS funnel was at 39%. The team wanted to redesign screens. I refused scope until we could measure where users actually dropped. Instrumentation first, hypotheses second, UX changes third. Completion moved 39% → 65% across ~400K applications/year.
Code review culture had plateaued. I wired SonarQube and semantic release into CI so quality and versioning became structural, not cultural. UI bugs dropped ~60%. Every deploy is versioned and linked back to its Sentry release.
The honest one. What I got wrong across projects, what changed my mind, and what the second version looked like. Senior engineering is learning in public — this is the one recruiters should read first if they want to see how I actually work.
Architecture demos that show how I approach contracts, data fetching, and quality.
Multi-tenant rental ops platform with the right infrastructure and none of it wired together. Traced 14 production-class failures — cross-tenant cache poisoning, float() on money totals, fail-open auth exposing real client data, PII in telemetry. Each bug ships with a postmortem and regression test; a Playwright tenant-switch test and three convention lints now block the whole class at CI.
An architecture demo modelling customers, projects, and assets with a typed GraphQL contract and a thin React UI on top.
Next.js app that shows how I handle data fetching, caching, loading states, and error paths with SWR and a clear quality setup.
Latest from Ownership in Practice. Short, practical pieces for engineers who want more ownership.
You fought for a clear spec and lost. The work still needs to happen. Here is what ownership looks like when the process does not go your way.
Contract-first development isn't process overhead. Here's what happens when you skip it, and why it matters even more when AI agents are writing your code.
A debug exercise with 3 reported bugs turned into 50 findings with one root cause. Here's what 14 fixes taught me about trust, patterns, and knowing when to stop.
Vague tickets become production bugs when AI agents write the code. Here's the 5-part template that makes tickets agent-ready before a single line is written.
Failures are feedback from the system.
The discipline behind saying no the right way.
How one clear owner prevents features from scattering.
Catch drift early, before users feel it
Agree the shape once. Generate types. Mock. Guard in CI.
Reader takeaway: how to turn a fuzzy “add city” ask into a safe first release you can extend.
Open to senior and staff product engineer roles in product companies.
Based in EU time zones. Available for remote or hybrid positions. Let's talk.