CosmicFOMO — Case Study

iOS/Android mobile game where real-time crypto price movement drives Fruit Ninja–style gameplay.

Summary

CosmicFOMO is a cross-platform mobile game. The gameplay loop is lightweight and arcade — slice-and-react mechanics inspired by Fruit Ninja — but the scoring surface is wired to live cryptocurrency price data, so every session is subtly different. topsweteam built the game end to end and scaled the backend to handle a few thousand concurrent players.

• Client: https://tothemoon.com
• Industry: Mobile gaming / Crypto
• Engagement: Full build-out
• Timeline: started 1 nov 2022 , finished 29 mar 2023
• Team: 1 frontend, 2 backend devs
• Status: Shipped, scaled to a few thousand users

Challenge

"A game on top of crypto prices" sounds like a gimmick until you try to implement it. The interesting technical constraint is that gameplay feel has to be deterministic and snappy (60 fps, sub-100ms reactions) while the scoring input is stochastic and externally-sourced. Missed or late price updates show up to the player as the game feeling "laggy" even when the render loop is fine. So the design challenge was as much about the data pipeline as it was about the gameplay.

Approach

We kept the game client lean and pushed the price-ingestion and smoothing logic onto the backend. The client consumes a normalized, rate-limited stream; it never talks to a crypto exchange directly. That put all the messiness — partial outages, ticker bursts, unreliable feeds — on the server where we could reason about it, and left the game runtime with a predictable input shape.

• Node.js + NestJS backend. Same stack as the team's other crypto-adjacent products; let us reuse ingestion infrastructure.
• React Native for the client. Acceptable performance for this kind of arcade game and cut the cross-platform cost compared to native Swift/Kotlin builds.
• GraphQL for the API. Useful during rapid iteration on scoring rules and in-game economy.

Solution

The system is three pieces: an ingestion layer that consumes live price feeds and normalizes them; a game-logic API that serves the client with a predictable stream of events and score updates; and a React Native client that handles the render loop and the interaction. Postgres stores game state, leaderboards, and audit trails. The AdminJS back-office is used for live-ops — balancing the economy, pushing promotional content, looking at player telemetry.

Key features shipped

• Cross-platform (iOS + Android) game client in React Native
• Real-time price-driven gameplay with a normalized server-side feed
• Player progression, leaderboards, and in-game economy
• Live-ops tooling in AdminJS for balancing and content pushes

Outcome

The game shipped on both platforms, and the backend held up through the first few thousand concurrent users without needing a rearchitecture — the ingestion-then-normalize decision paid off under load.

• Shipped on iOS and Android from a single React Native codebase
• Scaled to a few thousand concurrent players
• Stable gameplay feel despite inputs from a volatile live data source

Tech stack

Infrastructure: PostgreSQL, Docker Backend: Node.js, NestJS, TypeORM, GraphQL, AdminJS Mobile: React Native, React

What we learned

• "Client talks directly to the exchange" is almost always wrong for anything with a gameplay feel. Normalize server-side.
• React Native was sufficient for an arcade game at this scale; we'd reach for native only if we needed 3D or sub-frame physics work.
• Live-ops tooling is day-one work, not post-launch. Balancing a crypto-driven economy with a deploy-every-time loop would have been painful.