Helsinki, Finland · Senior product engineer
Experience.
How I work, in my job and on my side projects: one engineer across the whole product, with AI in every step.
Every layer of a digital product, and how I work on each.
Problem.
Find what's worth building.
Before any code, the question: who is this for, and what do they need? I talk to the people who'll use it, shape the product around them, then use AI to stress-test the plan until the gaps show.
- User needs
- Linear
- Prototypes
- AI sparring
Products shaped with the people who'll use them
Reproduce first
Seen before it's believed
A ticket describes a symptom. I reproduce it in the real product, in the browser or on a device, before deciding what the problem actually is.
With AI
Questioned before it's built
Before a plan becomes work, I let AI question it: what happens when, who is it for, what could go wrong. The gaps surface while they are still cheap to fix.
With AI
Mapped before it's planned
Before a change is planned, AI maps everything it will touch, so the plan starts from how the product really works, not from memory.
Design.
I design what I build, so nothing gets lost in a handoff.
I shape the flows, the interface and the design system myself, with agents as fast design partners. They draft screens in the real design system; I choose, refine and sign off. That works because the design system is code an AI can read.
- Design tokens
- Storybook
- AI proposals
- Visual regression
Design systems built from nothing, Storybook first
Tokens, not values
Colour, type, spacing, motion and shadow are tokens, in light and dark, so there's nothing for an agent to make up.
Guidelines as stories
Colour usage, accessibility, dark mode and iconography live in Storybook, next to the components they govern.
Drafted with agents
Agents draft new screens as proposal stories, in the real tokens, framed for both browser and phone. Only what I approve becomes a shipped screen.
Checked by machine
A test fails when text sits on a colour too light to read, and visual regression compares every story to its baseline in CI.
Apps.
Web and mobile, down to native code.
React and Next.js on the web. React Native on the phone, with Swift and Kotlin where the phone itself matters: background work, sensors, payments and security.
- React
- Next.js
- React Native
- Swift
- Kotlin
Frontends owned end to end, from the design system to native code
WebNext.js
- Next.js and React, typed end to end with TypeScript.
- Tailwind for styling, Storybook for the components.
- React frontends with their own design systems.
React NativeTypeScript
- One codebase for iOS and Android, native only where it earns its place.
- Interruptible animation with Reanimated.
- An API client typed from the server.
iOSSwift
- Background location and motion with Core Location and Core Motion.
- Work while the app is closed, with BGTaskScheduler.
- In-app purchases on StoreKit 2.
- Face ID sign-in, secrets in the iOS Keychain.
AndroidKotlin
- Foreground services and background location.
- Background work with WorkManager and coroutines.
- Biometric sign-in, secrets in Android Keystore.
Seven layers.
I work across all of them.
API.
A server worth trusting.
Typed NestJS APIs where the compiler and the tests guard what each person may see, and the clients can't drift apart from the server.
- NestJS
- TypeScript
- OpenAPI
- Zod
Typed APIs, from the database to the screen
Access control
Access control the compiler enforces
Data a user may see gets a type that only an access check can create. Skip the check and the code doesn't compile.
Contracts
One contract, both sides
Client types are generated from the API spec. Changing a field fails the build until the API version is bumped.
Testing
Tests that act like the real database
The test database applies real query filters and rejects anything production doesn't have, so a test proves which rows a query touches.
Data.
Keep the data right.
PostgreSQL and PostGIS underneath, Redis for queues and caching. Schema changes go through CI as migrations, never by hand.
- PostgreSQL
- PostGIS
- Supabase
- Drizzle
- Redis
- BullMQ
PostgreSQL, PostGIS and Redis in production
Security
Probed in CI
Every table needs row-level security, nothing private is publicly readable, and every table is part of the user's data export.
Caching
Caches that can't go stale quietly
A cached result carries a version of everything it was built from. Change any input and the cache misses.
Background work
On the right clock
Queues for slow work, and scheduled jobs that fire at each user's local time, never the server's.
Ship.
Get it to people, safely, again and again.
Every change, even a one-liner, goes through a pull request, review and two rounds of CI. One failed run anywhere and the release waits.
- GitHub Actions
- Railway
- Cloudflare Workers
- Sentry
- OpenTelemetry
CI/CD pipelines built from nothing
Deploys
Red means no deploy
A failed run on main blocks the deploy, so a broken build never reaches people.
Production
Watched, then learned from
Errors and performance go to Sentry and request metrics go out through OpenTelemetry. What breaks or slows down becomes a Linear issue for the next round.
Dependencies
Audited in CI
Dependencies are audited in CI, so a known vulnerability in a package shows up as a failing check.
Agents.
Agents write the code. The guardrails decide what ships.
Coding agents write a lot of the code I ship. My job is the system around them: the context they read first, and the checks that stop them cutting corners.
- Claude Code
- Skills
- Guard specs
- Lint rules
Built the rules, skills and checks my coding agents follow
1Before it writes a line
Teach
- Work starts from a Linear issue, so the agent knows why, not just what.
- Rules load only for the part of the code being touched.
- The AI reviewer reads the same rules as the writer.
- Every big decision is written down, and checked against the code.
2Before anything is saved
Check
- Custom lint rules for the mistakes this codebase actually makes.
- Tests that read the code itself, not just call it.
- New checks get broken on purpose once, to prove they can fail.
3Before it merges
Review
- An AI review on every pull request.
- Then a human reviews it before it merges.
- Nothing merges while a check is red, and the Linear issue gets the result.
$ npm run verify
✗ lintno-server-clockgetHours() reads the server's clock, and production runs in UTC
✗ specresource-access-bindinga route reads a user's data without an access check
✗ specunpaged-reada read that can pass 1,000 rows gets cut off without a word
✗ specdocs-driftCLAUDE.md points at a folder that no longer exists
4 checks failed. Nothing merges until they pass.
Still shipping.
Everything on this page is how I work today, and it keeps changing. Curious about any of it? I'm happy to compare notes.