Building a production community platform across mobile, realtime systems, and on-device AI.

Context

My responsibility

The challenge

Constraints

Unreliable networks

Mobile connections drop and resume constantly. The client can’t assume the socket is connected, and anything emitted while it isn’t can be lost.

Two platforms, three identity providers

iOS and Android differ on notifications, background execution and sign-in rules. Apple requires Sign in with Apple when other social logins are offered.

No native ML runtime

The classifier had to run in plain JavaScript. That rules out native inference libraries, but means a retrained model ships in an EAS update instead of a store release.

Bundle size

The model ships inside the JavaScript bundle, so every user pays for its size on install and on every update that changes it.

OTA boundary

Over-the-air updates can change JavaScript and assets only. Anything that touches native code needs a full Gradle build and store review.

Architecture

• Server state and client state are kept apart. TanStack Query owns anything fetched from the API — caching, refetching and invalidation. Redux Toolkit holds session and UI state that the server doesn’t own.
• Realtime lives in a single Socket context, so the connection lifecycle is managed in one place rather than per screen.
• The API client centralises auth headers and response handling, including 401s, so individual screens don’t each re-implement session expiry.

Exploration

Where should classification run?

A hosted LLM call per post would handle nuance best, but adds per-request cost, latency, a network dependency, and sends user text to a third party. Keyword rules are free and transparent but break on implicit language — “Gate 47, three-hour delay, I don’t care, I’m going” is about travel without using the word. A small supervised model sits between the two: it learns from examples and runs offline.

How big can the model be?

The first export stored each word vector as its own base64 string at 100 dimensions — about 5.5 MB. Repacking to one int8 blob at 50 dimensions with a single global scale brought the shipped module to about 768 KB.

Key decisions

An AI classifier that runs entirely on-device

function classify(text: string): Result {
const tokens = tokenise(text);              // lowercase, strip, length ≥ 2
if (tokens.length < 2) return UNCATEGORISED;

const sentence = averageEmbeddings(tokens); // int8 rows × global scale
if (!sentence) return UNCATEGORISED;        // no known words

const probs = softmax(CLASSES.map((c) => dot(c.vector, sentence)));
const top = argmax(probs);

return probs[top] >= 0.35
  ? { category: CLASSES[top].name, confidence: probs[top] }
  : { category: null, confidence: probs[top] };
}

Why this architecture

• Offline: classification works with no connection.
• Private: post text never leaves the device for this feature.
• Cheap: no per-request API cost. Inference is a lookup, an average and a 30 × 50 matrix product.
• Updatable: pure JavaScript, so a retrained model ships over the air.

Evaluation methodology

Implementation

Authentication

Google, Apple and Facebook sign-in feed one session. The Axios client attaches the token and handles 401 responses centrally — and only signals session expiry when a token was actually set, so unauthenticated calls don’t trigger a false logout.

Notifications and deep links

Firebase Cloud Messaging delivers pushes and Notifee handles on-device display. Deep links route a tap to the specific screen it refers to.

Realtime messages

Incoming socket payloads are checked for required fields before they enter state. Malformed messages are logged and dropped rather than rendered.

Theming

An app-wide theme provider supplies colour tokens, so dark mode is a token swap rather than per-screen overrides.

Tests

Jest covers the pending-event queue, socket analytics, view tracking, and the community-insight dashboards and their tabs — 14 test files at the time of writing.

Production

Crash reporting

Sentry captures crashes and errors from production builds.

Analytics

Mixpanel and Firebase Analytics track product usage. Socket-level view events go through the persisted queue described above.

Releases

Gradle app bundles for the Play Store, with EAS-managed version auto-increment. JavaScript changes go through the development channel, then the production channel.

Load testing

A Node harness replays the full onboarding sequence — register, username check, profile update, image upload, interest selection — for up to 1,000 accounts at once. k6 scenarios cover feed and moments traffic.

Screens

MobileChats· 1 / 5

Realtime chat list. Personal data redacted.

Outcome

Lessons

A validation score is only as good as the split behind it. I augmented each sentence into three near-copies before splitting, so 2,199 of 2,238 validation lines had a twin in training. The 99% measured memorisation. Splitting by source sentence first gives 60–64%: useful, but a different claim. I now split before augmenting, and report the method next to the number.

Next iteration

• Build an evaluation set from real, anonymised posts and report per-class precision, recall and a confusion matrix — the current numbers come from hand-written sentences.
• Evaluate the quantised JavaScript model directly. Today’s scores are from the float model before int8 export.
• Tune the 0.35 threshold against a precision target on real data instead of choosing it by hand.
• Extend automated tests to reconnection and notification routing, where failures are hardest to reproduce by hand.