Selected work

Eight products I took from problem to production.

Preview of Woofwatch

A guard dog for your CCTV that barks on your iPhone

Product design · iOS engineering · Backend · Founder

The problem

Home cameras already see the person at the gate at 2 AM. They just tell you in a silent notification you read the next morning, buried under every leaf and cat that tripped the motion sensor.

What I built

  • A native iPhone app where your phone barks in a real dog voice the moment a camera sees a person, even locked, with the app closed and through Do Not Disturb
  • A tiny Cloudflare relay that cameras call directly (Hikvision HTTP Listening, Reolink Webhook) and that pushes the bark, a live alert with a one tap Live button, and a clip that starts five seconds before the bark
  • A Home hub mode for every other camera: a spare iPhone watches any RTSP stream with on device person detection, plus my own RTSP player, a home screen dog you can pet, and the marketing site with a dog that watches your cursor

The hard part

iOS never lets an app watch video in the background, and a silent audio trick to stay awake gets rejected by App Review. So the phone stopped being the detector. The camera or a home hub detects, a small server sends the push, and the phone only has to bark. Getting there meant writing an RTSP client from scratch after VLC broke on iOS 26, caching the APNs token after Apple rate limited a fresh one per bark, and keeping the alert quiet while you are already watching the live view.

Outcome

Woofwatch is in final testing before the App Store, with the launch list open at getwoofwatch.netlify.app. Barks reach a locked phone within seconds of a person walking into frame, each with its own clip.

Preview of Pixilmate

Pixel art, animation, and a hiring path for artists

Product design · Frontend · Backend · AI integration · Founder

The problem

Pixel artists and indie game developers juggle separate tools to draw, animate, and export spritesheets, then juggle separate platforms again just to get noticed by studios that could hire them.

What I built

  • A pixel editor and animation workflow that takes artists from a blank canvas to an exportable spritesheet in one tool
  • A community showcase gallery where artists post work, enter challenges, and get discovered
  • A direct hiring path between artists and game developers with 0% commission on the platform

The hard part

The hardest technical problem was storage. Raw pixel canvases balloon fast, and cloud costs scale with every artist’s file history. I decided to encode runs of identical pixels instead of storing every pixel individually. Pixel art is mostly flat color regions, so this compresses extremely well without losing a single pixel of data. A 48MB canvas becomes about 124KB, and decodes back to full resolution in under a millisecond.

Outcome

Pixilmate is live at pixilmate.com and currently has 322 users. AetherAI, an AI pixel platform out of Korea and Taiwan, retired their own editor and moved their whole pixel workflow onto it. Every product, design, and engineering call on Pixilmate still runs through one person, end to end.

Preview of ArchLab

Local-first AI that maps codebase architecture

Product design · Full-stack engineering · AI systemsOpen Source

The problem

Understanding a codebase’s architecture usually means reading through files by hand or sending code to a third-party AI tool you may not want your source touching.

What I built

  • A tool that analyzes a project’s architecture entirely on your own machine, with nothing sent externally
  • An interactive canvas mapping how the frontend and backend connect, plus a step-by-step check for security, performance, and scaling issues
  • Six focused AI agents (security, performance, database, code quality, architecture, orchestration) that reason about the system, and a way for other AI tools to plug directly into it

The hard part

The hardest call was refusing the easy path of wrapping a cloud AI API and calling it done. I decided every agent had to run entirely on the developer’s own machine instead, with nothing about their codebase ever leaving it. Privacy isn’t something you bolt on later, and a tool that starts by asking teams to trust a cloud API with proprietary code will never get adopted by the teams that need it most. All six agents run against a local pipeline and render straight into the canvas, no network round trip required.

Outcome

Open source on GitHub. ArchLab is where my systems-thinking side shows up directly. I built the tool I wanted for reasoning about architecture, instead of looking for one.

Preview of Perchie

A calm companion that lives in the MacBook notch

Product design · macOS engineering · Founder

The problem

People who work long hours at a screen get nothing looking out for the human doing the work. The wellbeing apps that exist fire on fixed timers, interrupt whatever you were in the middle of, and get muted within a day.

What I built

  • A companion that lives in the MacBook notch and checks in out loud at natural pauses, with a morning hello, a nudge to drink or stretch after too long on screen, and a one-tap wind-down that ends the day and puts the Mac to sleep
  • A read of safe local signals only, session length, idle time, calendar, quiet hours, and the frontmost app, with nothing about the user ever leaving their machine
  • Six companion personalities with a hand-written check-in library, a native Liquid Glass panel that drops from the notch, and a one-time purchase with no subscription and no account

The hard part

The hard part was timing, not the interface. An early reminder engine marked a check-in as shown the moment it qualified, so when a higher-priority nudge qualified in the same five-second tick as a lower one, the lower one was silently and permanently skipped. I rebuilt it so a check-in only commits to its fired state on confirmed delivery, never on qualifying. The same rule shapes the product. Perchie never speaks while you are mid-flow, only once you have already paused, because a companion that interrupts is one you turn off.

Outcome

Perchie is my RevenueCat Shipaton 2026 entry, built for the Mac App Store. I got so deep into chasing my dream that I forgot to eat, drink, or move, so I built the companion I wish I had, for the next builder before they learn it the hard way.

Preview of Gecko

Real-time electricity tracking that ends bill shock

Product design · Flutter engineering · Founder

The problem

An admin at Southwestern University PHINMA told me she could not find a single app that properly tracked her electric bill. Filipino households get hit with bill shock at the end of the month with nothing showing the cost adding up while it happens.

What I built

  • A phone app that tracks electricity per device in real time. Switch a device on and watch its kWh and cost climb against the month so far
  • An energy-trend chart that separates the whole household’s draw from just the devices running right now, with every day kept as its own permanent record
  • Fully local, with everything saved on the device and no account or backend

The hard part

Gecko started in React Native, and a tab bar that jittered on every screen change turned into the kind of bug that swallows a week. I decided to rewrite the whole app in Flutter instead of patching around it. Throwing away working code stings, but shipping on a foundation you are fighting is slower in every direction, and the rewrite had paid for itself before the app was back to where it started.

Outcome

Gecko is on the App Store, with the newest build still on its way there. It is the first thing I carried the whole way from a real person’s problem to a shipped product, and it started with one sentence: I cannot find an app that does this.

Preview of Chomp Snake & Dice

Snakes and Ladders where shaking your phone rolls the dice

Product design · iOS engineering · Sound design · Founder

The problem

Snakes and Ladders on a phone usually means tapping a button and watching a number appear. The best part of the real game, picking up the dice and feeling them rattle, is the first thing that gets lost.

What I built

  • A native iPhone, iPad, and Mac game where shaking the device is the controller, with three dice tumbling under real 3D physics and clacking off the tray walls with haptics on every hit
  • Five hand-made boards that get snakier as you go, living snakes whose eyes track your token and swallow the dice whole, and pass-the-phone or vs Computer play for up to six players
  • Every sound synthesized in code, no audio files, including a looping 8-bit chiptune soundtrack for each level, plus a marketing site with a playable demo running the same rules

The hard part

Two things. First, honest dice. The result is never picked at random and animated toward. Each die reads the face pointing most upward once the physics body comes to rest, and a die cocked on an edge gets nudged until it lies flat. Second, the music. On a real iPhone the app opened to the splash and got killed two seconds later with no crash report, while the simulator ran fine. I bisected startup on the device and found the soundtrack synthesizer rebuilding its note tables for every one of about 400,000 samples per track, pegging the CPU at launch. Hoisting the tables and synthesizing each track off the main thread on demand fixed it.

Outcome

Chomp is live on the App Store, with a playable demo at chomped.kinperez.com. It is the purest version of the style I care about most: every roll, hop, and bite should feel like a little show.

Preview of Learning Pod

Role-aware platform for at-risk-student coaching

Product design · Full-stack engineering · Systems

The problem

At Southwestern University PHINMA, one staff member ran the entire at-risk-student coaching program by hand across spreadsheets. As more students came through, that meant constant human error and no way to keep up.

What I built

  • A role-aware platform where each of the six institutional roles sees exactly what they need and nothing more, enforced at the database with row-level security
  • Referral, scheduling, coaching-session, and attendance tracking, with PDF and Excel report generation
  • A staged approval workflow where Staff pushes a report, Admin reviews and can send it back, Admin escalates, the President gives final sign-off, so every institutional change stays accountable

The hard part

The hard part was scale. This is the whole scholarship program, thousands of students, and the same screens have to enforce six roles down to the individual row: a President sees read-only KPIs, a Coach sees only their own students. I pushed that into row-level security at the database instead of guarding it in the interface, so a missed check in a component cannot leak anything, and every referral list, session log, and report stays filtered per-user without slowing down as the student count climbs.

Outcome

Learning Pod is live at learningpod.kinperez.com, and v2 is live at learningpodnew.netlify.app. It replaces the shared spreadsheets and the manual report cycle the program used to run on. Referrals, coaching sessions, and every approval up to the President are now tracked in one place instead of passed around by hand. I am also building the website and CMS for the same university, live at southwestern-phinma.netlify.app.

Preview of FlowK

One guide your AI follows so your app explains itself

Product design · Framework design · Frontend · FounderOpen Source

The problem

A client demo went wrong on a multi-role app I built. With several kinds of users, someone new could not follow who does what, and there was no safe way to click around without touching real data. Every app with more than one role hits that wall the moment someone has to learn it without the builder in the room.

What I built

  • Kin’s Flow, an open-source guide you hand to an AI coding tool like Claude Code or Cursor. It maps who starts the work and who finishes it, checks that map with you, then builds six parts into the app
  • Practice logins that can never change real data, a “Show me around” tour for each kind of user, an “Explain this page” button, small “i” buttons on every card, a map of how everyone connects, and a guided first-login setup
  • FlowK, the site for the method, which runs the method on itself with its own tour, “i” buttons, and How it works map, plus a one-click prompt to paste into any AI coding tool

The hard part

The hard part was a demo that truly cannot touch live data. Checking for demo mode screen by screen leaks the moment one screen forgets, and a demo tab can inherit a real logged-in session, so database rules alone are not enough. The guide has the AI wrap the one database client instead, so every write is blocked before it reaches the network while reads keep working, and a test turns demo mode on, tries every write path, and fails if a single request goes out.

Outcome

FlowK is live at flowkin.kinperez.com, and the framework is open source on GitHub under MIT. It turns the lesson from one bad demo into something any builder can hand to their AI, so their app can explain itself without them there.

Preview of Pocketpad

Your phone is the controller, your TV is the console

Product design · Apple platform engineering · Founder

The problem

Couch games ask for a lot before anyone gets to play: a gamepad for every friend, an install, an account. Meanwhile everyone in the room is already holding a phone that could be the controller.

What I built

  • An Apple TV host that opens a room with a QR code, where up to 12 players drop in as toy characters, each in their own color
  • An iPhone controller that finds the TV on the local network and flips into a gamepad with a stick, four face buttons, and a haptic thud when you join
  • A browser controller the host serves by itself, so a friend without the app can scan the QR code and play with no install, no account, and no server

The hard part

The hard part was getting 12 phones into one room with low lag and no friction. The easy options each failed one of those. Apple’s peer to peer framework caps at 8 players, Game Center makes every guest sign in, and a cloud relay adds lag and a server to run for something that happens in one room. I built on Network.framework with Bonjour instead, with the host deciding everything, and had the host serve its own controller page over the local network so browser guests use the same messages as the app.

Outcome

Pocketpad is coming soon, with a waitlist open at pocketpad.kinperez.com. The lobby and controllers are built, with the launch game and AirPlay hosting still on the way.

One more, on the smaller side.