JAMIE
A persistent AI development partner built on agent harnessing and context engineering.
[ read case study ][ Case Study ]
Availo
The digital bulletin board — events are posters, and the people and calendars you share them with are the boards they pin to.
// Native iOS and Android, built on Loom's tokens
Preparing for the App Store
- Expo
- React Native
- Drizzle
- GraphQL
- Supabase
[ The Problem ]
The bulletin board used to hang somewhere real — the library corkboard, the cafe window, the community-center hallway. It's how you found the chess club, the run group, the open mic. Strangers posting to strangers, in a place everyone already passed through.
Those places are thinning out. The third spaces where community used to form — where you'd stumble onto something and just show up — keep closing or moving behind a screen. What's left is the group chat you're already in: fine for the plans you'd make anyway, useless for finding the ones you wouldn't.
The corkboard didn't just hold the plan. It's where you found the group in the first place.
Availo is that board, rebuilt for a world running out of walls to pin things to. An event is a poster; the people and calendar groups you share it with are the boards it's pinned to. Some boards are private — you and the friends you already have. Others are public: a community's activity feed that a stranger nearby can find, follow, and show up to.
[ Architecture ]
Availo is three pieces — the model the whole thing runs on, the native app itself, and the backend under it. End to end.
- 01
The model
The whole app is one idea made concrete: an event is a poster, and its host is either a person or a calendar group — the board it's pinned to. A board can be private — you and your friends — or public, a community anyone nearby can find and join. Get that model right and the rest is mostly modeling — discovery, the feed, and permissions all fall out of how the pieces relate.
- 02
The app
A native iOS and Android app from one Expo / React Native codebase, styled on Loom's design tokens so it reads as a finished product rather than a prototype. The components are hand-built for the native runtime, but the look and the vocabulary are the same system behind everything else here.
- 03
The backend
A GraphQL API over managed Postgres — every entity its own module, and the database typed end to end so a schema change is a reviewable diff, not a guess. The kind of production wiring a real app needs, on a side project.
[ Decisions ]
Discovery you opt into, not a feed that grabs you. The public side could have been an endless ranked feed — the move every social app makes. Availo's isn't. Finding a group is a search: by proximity, by interest, or by name, and nothing surfaces that you didn't ask for. That's the corkboard on purpose — a bulletin board doesn't decide what you see; you walk up and read it. The cost is that discovery takes a little intent. The point is that it should: the goal is getting people to a real thing in the real world, not holding them in the app.
Loom's values, not Loom's components. Availo is Loom's first native consumer, and React Native can't run the web catalog's components. So I ported what actually travels — the token values and the naming vocabulary — into NativeWind, and hand-built the native atoms on top. The cost is real: the atoms are re-authored, not shared. The payoff is that the app is visually and structurally a sibling of the web work without forcing a web component into a runtime it was never meant for. It's the portable-system boundary, tested on the hardest case.
[ Built to Go Public ]
Shipping an app in 2026 means shipping into a hostile environment. Automated recon is cheap, and in the AI age an attacker doesn't need to be a person patiently poking at an API — a script finds the unlocked door in minutes. A small indie app is exactly the kind of soft target that gets swept up in that, right up until it doesn't.
So before I called Availo done, I ran it through a security review. The lens is one I built into JAMIE, my development system — a checklist grounded in current cybersecurity best practices — pointed at the whole app: locking the data layer down by default, making tokens instantly revocable, rate-limiting the entry points, and keeping personal data off the wire where it didn't belong. None of it is glamorous, and that's the point — it's the difference between an app that's ready to be public and one that simply hasn't been attacked yet. It's what gives Availo a fighting chance the day it goes live on the App Store.
[ Under the Hood ]
Two slices — the bulletin-board concept in the type system, and the discovery query that lets a stranger find a public group nearby.
The bulletin-board concept, in the type system. An event's hostis a union — a person or a calendar group — so "posted to a board" is a real type, not a convention. The computed fields are viewer-relative: the same query answers friendsGoingCount and available differently for every requester.
> server/api/Event/Event.schema.ts
union EventHost = User | CalendarGroup
type Event {
id: ID!
title: String!
host: EventHost! # a user or a calendar group
cohosts: [User!]! # share edit powers, except removal
start: DateTime!
venue: String
city: City # canonical city (carries coordinates)
price: Money # null = free
capacity: Int # null = unlimited
visibility: EventVisibility!
interests: [Interest!]!
goingAttendees(limit: Int): [RSVP!]!
# Viewer-relative, computed from RSVPs.
friendsGoingCount: Int! # GOING RSVPs whose user is a friend of the requester
myRsvp: RSVP
canManage: Boolean! # host, host-group organizer, or co-host
available: Boolean! # open spots AND the viewer's calendar is free
}[ More Case Studies ]
Loom
A design-system pipeline that scaffolds application UI from a single config source.
[ read case study ]