A pixel hand cursor
A pixel hand cursor
A pixel hand cursor
A pixel hand cursor

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.

Seven layersOne engineer, with agents

Every layer of a digital product, and how I work on each.

01 / 07The problem

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.

Next · 02 Design ↓

02 / 07The design

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.

Next · 03 Apps ↓

03 / 07Web and mobile

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.

Next · 04 API ↓

Seven layers.
I work across all of them.

04 / 07The server

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.

Next · 05 Data ↓

05 / 07The data

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.

Next · 06 Ship ↓

06 / 07Shipping it

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.

Next · 07 Agents ↓

07 / 07Coding agents

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

  1. 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.
  2. 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.
  3. 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.
When an agent cuts a corner, this is what it gets back
agent branch · npm run verify

$ 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.

Try sneaking a shortcut past them yourself ↑

Back to the seven layers ↑

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.