How it started
I'm learning Tagalog. My girlfriend's family speaks it, and I wanted to follow a conversation at the dinner table rather than smile politely through it, so I found a tutor on Preply and started having proper lessons. The lessons were the easy part. The hard part was everything in between them. The words I picked up on Monday were mostly gone by Thursday, and I had nowhere sensible to keep them.
I tried the obvious apps first. Duolingo and Babbel are good at what they do, but what they do is teach you their course, in their order, at their pace. None of them had room for the words my tutor actually gave me, or the ones I overheard at a family lunch and wanted to hang onto. The thing I needed didn't exist, which was somewhere to practise the vocabulary that was already mine.
So I started designing it. The working name is Tanda — Tagalog for a mark or a sign, and close enough to "to remember" in a few languages that it stuck.
What it is
Tanda ships no curriculum of its own, and that's the whole idea. The words come from you and your tutor, and Tanda is the practice engine that sits between your lessons and keeps what you're learning from slipping away. It isn't trying to replace the teacher. It's trying to be the thing that makes the hour you spent with them actually stick.
It's phone-first, because that's where the practice has to happen. On the commute, in a queue, on the sofa, usually on a connection that drops every few minutes. I designed for the phone first and let the desktop layout breathe into the extra room afterwards, rather than the other way around.
Three kinds of people use it. Learners are the core. They record words, build decks, and review daily. Tutors connect to their students, assign decks as homework, and over time get to see which words a student keeps getting wrong. Learning partners are two ordinary learners, a couple or a pair of friends, who connect as equals to share decks and watch each other's progress.
The three layers
The data model is small enough to hold in your head, which was the point. Three layers, kept visually and conceptually distinct.
An entry is the atomic thing: a term, its translation, the part of speech, an example sentence, maybe a note or a tag, maybe a recording. Entries live in your library and nowhere else. A deck is a named collection of them, like "Everyday Tagalog" or "Words from this week's lesson". A deck only references entries, so the same word can sit in as many decks as you like without ever being copied.
A play mode is the one thing that isn't an object you save. You choose it at the moment you practise, not before: multiple-choice or type-the-answer, term-to-translation or the reverse. A practice session is just a deck plus a mode, assembled on the spot and thrown away when you're done.
The signature moment
If a hiring manager opens Tanda and looks at exactly one screen, I want it to be practice, because practice is where the craft lives.
A card comes up with the prompt. You answer, by tapping a choice or typing it, and the card flips, grades you, and settles. Behind that calm surface is a Leitner box system. Get a word right and it climbs a box and comes back less often. Get it wrong and it drops back to box one, and you'll see it again tomorrow. The completion screen at the end doesn't throw confetti at you. It quietly shows which words moved up a box, because the satisfying part was never a badge, it's the evidence that something stuck.
The motion is doing a lot of the work here. The flip runs on a real spring rather than a fixed duration, the grade lands with a small physical settle instead of a snap, and nothing bounces for the sake of bouncing. The curves are the ones I keep coming back to: cubic-bezier(0.23, 1, 0.32, 1) for the calm exits, a gentle spring for the flip itself. It's the Emil Kowalski school of motion, the kind you only notice because its absence would feel wrong.
The daily loop
The home screen is the daily ritual, and it's called Today. It tells you how many words are due, shows your boxes filling in, and keeps a streak. Then it stops.
I have strong feelings about this part. Most learning apps are built to make you anxious, between the broken-streak guilt trip, the guilt-tripping owl, and the notification that all but emotionally blackmails you back in. I find the whole genre exhausting, and I designed Tanda to be the opposite. One gentle daily nudge, a streak you're allowed to break without being punished for it, and progress shown because it's genuinely motivating rather than because it props up a retention metric. A review heatmap fills in over the weeks and a mastery distribution shows how your words spread across the boxes. Calm, not coercive.
Your words
The library is the home base: every word you own, searchable and filterable by tag, language, deck, or whether it still needs work.
Adding words is where most apps get the friction wrong. Tanda lets you add one by hand, with full control, because half the point is that these are your words and you decided they mattered. There's an optional suggest action that uses AI to propose a translation, a part of speech, and an example sentence, but it only ever proposes. You review and edit before anything saves, and it never quietly overwrites what you wrote. For the times you've got a whole lesson's worth at once, you can paste a list or a CSV, or drop in your messy lesson notes and let an AI pass pull out the candidate words as a checklist you confirm.
Every entry carries a small audio control that turns up all over the app. It plays your tutor's recording if there is one, falls back to generated speech if there isn't, and lets you record your own attempt to compare against it.
People and teaching
Everyone you're connected to lives on a single Connections surface, each tagged as a tutor or a partner. Tutor connections are asymmetric, in that the tutor assigns and the student receives. Partner connections are symmetric, so either side can share a deck or send a word across.
Homework is the student side of that relationship: an inbox of decks your tutor has assigned, with due dates. Doing the homework means practising the tutor's deck, which you get read-only. If you want to change it, you clone it into your own library as a fork rather than a live edit, so the tutor's original can't shift under you halfway through the week.
The tutor dashboard is the part I'm most interested in and the part that's hardest to do well. A roster of students, a per-student view with their progress and accuracy and homework completion, and the one feature I think actually earns its place: struggle-word analytics. Which entries a given student keeps failing, laid out so a tutor can glance at it before a lesson and know exactly what to cover. I designed the whole dashboard knowing it would look sparse until real usage sat behind it, which forced a useful principle. Record the events, derive the views, so the layouts can fill in with history over time without ever needing a redesign.
Growth and money
A new app with an empty library is a dead app, so there's a community library: published decks like "500 Essential Tagalog Words" that you clone into your own collection and then edit freely. Cloning is forking again, so your copy is yours and the original can't silently rewrite it. Quality is layered rather than gatekept, with author attribution, a clone count, ratings, per-entry error reports, and a verified badge held in reserve for tutor decks. When someone publishes a deck, a cheap AI pass flags any entries whose translations look suspect, as a speed bump for the author to confirm rather than a wall.
The money model is freemium, and the rule I held to is simple: gate capability, never the user's own words. Free gives you the core practice modes, a cap of around a hundred entries, basic stats, one daily reminder, and offline for your active deck. Pro lifts the caps and adds full offline, richer stats, smarter reminders, and premium audio, with a higher tier again for tutors who want the dashboard. There are no ads anywhere, and the upgrade prompts only appear at honest moments, like the one where you try to add your hundred-and-first word, rather than nagging you the whole way there. The pricing leans on the annual plan, because I'd rather charge a fair yearly number than dress a monthly one up to look small.
First run
Onboarding has one job before it asks for anything, which is to get you to a word you actually remember. You go through a tiny practice loop with a handful of seeded words, feel one of them land, and only then does Tanda suggest saving what you've started. Sign-up is framed as keeping your progress rather than unlocking the app, it's passwordless, and there's no wall thrown up before you've felt the thing work. Asking someone to commit before they've felt anything is how you lose them on the first screen.
The look
The palette is warm clay over warm neutrals. A burnt-orange #c5603d does the accent work, with amber and a muted sage carrying the secondary signals, all of it sitting on a near-black that's properly warm rather than blue-grey, or a paper cream in the light theme. Nothing is pure black or pure white. Both themes are designed rather than generated from one another, with the dark one as the home register and the light one as its own considered thing.
The type is three faces working together. Newsreader, an editorial serif, carries the display moments and the occasional italic. Geist does the interface and body work. Geist Mono handles the small uppercase labels, the due counts, the timestamps. It's the serif-plus-humanist-sans-plus-monospace combination that reads as considered rather than branded, and a deliberate distance from the Inter-and-a-purple-gradient default that most new apps still reach for.
Where it is now
Tanda is built to a v1 MVP. The screens here aren't mockups, they're the real app: the spring physics running, the Leitner scheduler deciding what's due, the library and the practice loop and the tutor side all working end to end. I designed it in Claude's design tool first, so I could feel the interactions before committing to them, then built it for real in React Native and Expo, because the gestures and the haptics and the offline-first behaviour all wanted to be native rather than faked in a browser.
I'm calling it in progress because it honestly is. The MVP works, but there's a long list before I'd call it done, between premium audio, the deeper tutor analytics, the community library at any real scale, and an actual launch. I'd rather show the work mid-flight than sit on it until then. Of everything in this portfolio, Tanda is the piece I most wanted to make. It's the clearest version I have of the work I'm moving toward, which is a real product, designed and built by the same person, where the interaction craft is the point rather than a coat of paint at the end.