ikieEngineeringGet started

ikie Engineering

Notes from building ikie

A calendar that keeps up with your finger, and one app that follows the same rules on the web and iPhone. What we measure, fix and learn along the way.

DocsData modeliOSUniversal Links

Docs became pages: a tree, a home, past versions, links that open the app

Three days after building docs you attach to events, we turned them into Notion-style pages, made it possible to bring back text deleted by mistake, and made links open in the app. This is about choosing what to store and what to compute.

Read the post

Names instead of emails: an attendee list people can read

A meeting's attendee list full of email addresses doesn't tell you at a glance who's coming. This is how ikie looks at your own labels, people you know on ikie, Google contacts and device contacts in turn, without letting anyone probe a stranger's name.

Hum, then pop: carrying a block into the next day

In ikie's day view you can hold an event and push past the end of the day to land in the next one. It started as "hold at the edge for 0.6 s". Over a week and seventeen PRs it became distance, a rubber band, a charge that fills up, and bent space. This is how we pinned a feeling down with numbers and tests.

While you swipe, only one thing should change

Every swipe in ikie's week view froze the screen for a moment. Instead of polishing drawing code, we used page values and a UIKit pager to shrink how much gets recomputed on each change.

A few milliseconds more, and the stall grew fivefold

Flicking the handle quickly between ikie's small and big calendars made the screen stutter. We tested four guesses by replaying the exact same gesture on builds from before and after a rework, and found that what blew up the stall was a threshold: one frame. Bringing each drag update down to 3 ms took the stall after release from around 130 ms to around 10 ms.

A screenshot test caught a 5.7-second database query

We photograph thirteen key web screens with the server and browser clocks frozen, and compare them pixel by pixel with saved images. It ran 700 times in eight days, and we sorted all 26 failures. One of them pointed not at a picture but at the database.

Colors, type and motion live in one JSON, shared by web and iOS

ikie's colors, type, spacing, corners and motion are 165 tokens. Written once in JSON, they become web CSS and iOS Swift, and tests measure 96 contrast pairs and the spring curves. Screen CSS can't spell out a color or font size as a number.

Seven other apps' tasks, one engine

Tasks from Notion, Slack, Todoist, Linear, Google Tasks, Microsoft To Do and GitHub land in the ikie inbox. The only thing that differs per source is the field mapping, so each adapter is 160 to 350 lines. Three fields merge three ways, and webhook bodies are treated as signals, never trusted.

The Claude that builds ikie logs its work in ikie, with no AI-only fields

For every request, a Claude session makes a task in ikie and records steps, PRs and results inside it. We built an AI-only work system in a day, removed it the next morning, and redid it with features people use. The rules are written in one place, and the guidance, hooks and checks are generated from there. Of 41 gaps found along the way, 36 are fixed.

A security review before launch: every fix landed in one place

We went through 140-odd API paths, the connected Claude (MCP), external calendars and webhooks, payments and the iOS app. We found 4 high and 9 medium issues and closed them that night in five PRs. The fixes looked alike: move the decision to one place and make every door go through it.

Rebuilding the inbox: 10 of 16 ideas, in both apps

We compared six apps, let the owner pick from mockups, and shipped filters, multi-select, manual order, saved views and plan-my-day to web and iPhone in 10 PRs. The server decides filter values and the screen only compares them. Bulk actions got no new server path.

Write in Notion-style blocks, store plain Markdown

We built documents you attach to events and tasks in one day. We threw away the first editor for Notion-style blocks, and on iPhone each block is its own native text view. Even so, a block you didn't touch doesn't change by a single character, because a connected Claude edits documents by finding and replacing text.

We left the screens alone and made the app ask the server less

Opening the iOS app went from 12 requests to 4, and opening an event sheet from 4 to 1. Screens and models still ask for things one by one; an adapter under them batches calls made in the same moment. Along the way a deploy stalled production for three minutes, and that is in here too.

We tested only what changed, and PRs did not get faster

The day after moving CI to one Mac Studio, we made PRs run only the tests that touch what changed. The median did not move and the slow end got slower. Here is why, and the other things we fixed on the same Mac that day.

We filled the database with 10,000 users, and something else broke first

Production got a little slower, so we measured where ikie would fall over first, with a test database of 10,000 sign-ups and an estimate for 1,000 people online at once. The board query went from 527 ms to 5 ms and the alarm cron from 462 seconds to 40 ms. But the first thing to break wasn't the board. It was the calendar sync that ran every time someone opened the app.

An untouched screen woke up 1,851 times in 10 seconds

Within a day the whole app felt sluggish, and measuring three builds side by side pointed to the biggest cause: a small shimmer decorating flagged tasks. Here's how we cut main-thread work during 10 untouched seconds from 488 ms to 8 ms.

We merge external calendars field by field, three ways

So that edits made in Google and in ikie to the same event both survive, ikie remembers the last value both sides agreed on and compares three versions for each group of fields. One engine reconciles Google, iCloud, Outlook, iPhone calendars and .ics subscriptions this way, and never throws away fields it doesn't understand.

We don't store repeating events

ikie never stores the occurrences of a repeating event. It stores the rule and computes occurrences whenever you look. Here is how an unstored occurrence gets an address, and how that address survives editing "all events" or "this and following".

We write our principles in tests, not documents

Principles written in a wiki are the first thing forgotten when things get busy. Here are the eight principles ikie holds, with real cases where we broke them and the tests that now stop such code before review.

Write while offline, and it sends itself when you're back

Finish a task on the subway or move an event on a plane, and ikie shows it right away, then sends it to the server on its own once you're connected. Here's how we decide which writes can wait and which to refuse, how sending twice still creates only one item, and how we put every write in one line and then split it up again.

We don't let the small model do dates

ikie turns a one-line note like "dentist tomorrow at 3" into an event without any LLM on the server. Here's how we let rules compute the date and time, left a small on-device model just one question (event or task?), and measured the rules and three models against one test set.

Time comes in four kinds

A birthday is a whole day, a call with a colleague in New York is one instant, and an 8 am pill is 8 am wherever you are. Here's how ikie stores time as four kinds, and where time tripped us up, from a block shifted nine hours to an event whose end landed before its start on a DST day.

We don't store your plan, we compute it

ikie has no column that says "this person pays". We record only facts, App Store subscriptions and grants, and compute the plan and any pauses on every request, so nothing is deleted or changed when a plan ends and nothing needs undoing when someone subscribes again.

We build a graph from our code to answer "what breaks if I change this?"

ikie answers "what else do I need to look at if I change this?" with a graph built automatically from our TypeScript and Swift code, the database, the API contract and the app policy. On every PR, a human-verified answer key scores whether the graph gets it right, and CI blocks the gaps in our principles that the graph exposes.

We moved CI to one Mac Studio

Once PR pushes passed 100 a day, GitHub Actions burned about 2,900 minutes in a single day. We moved every job to four runners on one Mac Studio, took GitHub-hosted runner usage to zero, and ran into a few things while sharing that machine with iOS builds and simulators.