• 

GymOS: Complete gym management built for YOUR gym

Inspiration

We run a small gym in the Philippines. Business was growing - but so was the chaos.

Members asked about their status through WhatsApp, Facebook Messenger, Viber. We tracked everything in Pen and Paper or Google Sheets. When someone asked "Am I still active?", we have to open the spreadsheet, scroll, and hope we don't make mistakes.

Then I got quoted ₱25,000 for gym management software that couldn't work offline (power cuts are common in the Philippines), had no ghost member detection, no mobile app for members, and required monthly fees on top.

As a developer and gym owner, I knew I could build better. So I did - for ₱1,000 all in.

What it does

GymOS is a complete gym management system across three platforms:

🔌 IoT Check-in Kiosk

• M5StickC Plus with WS1850S NFC reader (13.56MHz)
• Members tap their NFC card → instant check-in
• Works offline - queues check-ins when power/internet is out, auto-syncs when connection returns
• Cost: ₱1,000 (~$20 USD)

💻 Staff Dashboard

• Real-time member tracking
• Ghost Detection: Alerts when paid members haven't shown up in 10+ days (prevents silent churn)
• Expiry alerts with revenue potential: "₱2,350 if all renew"
• Daily revenue tracking by pass type
• Live occupancy: "21 members here right now"
• Staff access controls
• Offline-first: Visit logging works without internet

📱 Member Mobile App

• Check-in notifications
• Membership status and expiry countdown
• Complete attendance history
• No more "Am I still active?" calls to staff

All three platforms sync in real-time via WebSocket. When the power goes out, everything keeps working.

How we built it

Tech Stack

• Hardware: M5StickC Plus (ESP32) + WS1850S NFC Reader
• Backend: Node.js + Express + PostgreSQL (Supabase) + WebSocket
• Web: React 18 + TypeScript + IndexedDB (offline storage)
• Mobile: React Native + Push notifications

The Kiro-Powered Workflow

Built while sick, during dinner breaks:

• ESP32 firmware for NFC reading
• Node.js backend with offline queue
• React dashboard core features
• Mobile app development
• Ghost Detection algorithm
• Real-time WebSocket sync
• UI polish

Frontend-Driven Development (My Discovery)

I discovered a novel Kiro workflow I call "Frontend-Driven Development":

Traditional: Write Spec → Backend → Frontend → Integration Hell

My Approach: Vibe Code Frontend (with mocks) → Generate Spec FROM Frontend → Build Backend FROM Spec

Process:

1. Vibe coded the dashboard with mocked backend data - iterated rapidly on UX
2. Asked Kiro: "Analyze this UI and create a backend spec that provides all the data it needs"
3. Built backend using spec-driven development from that generated spec

Result: Zero integration bugs. The frontend defined the contract, the backend implemented it perfectly.

Multi-Platform Consistency

Building three platforms (ESP32 C++, React TypeScript, React Native) simultaneously needed coordination.

Solution: Kiro's Steering Docs + Agent Hooks

Created steering docs defining data models, API contracts, and naming conventions for ALL platforms.

Result: Three platforms speaking the same language from day one.

Challenges we ran into

Challenge 1: Three Platforms, One Data Model

Problem: ESP32 firmware (C++), Node.js backend, and two React frontends all need identical data models.

Solution: Kiro's docs became the single source of truth. Every code generation referenced the documents.

Result: Zero data model mismatch bugs.

Challenge 2: Offline-First for Philippine Reality

Problem: Power cuts are common. Internet drops frequently. The system MUST work offline.

Solution:

• Queue on web dashboard
• Local storage on ESP32
• Automatic sync when connection returns
• Visual offline indicators

Learning: In the Philippines, offline-first isn't a nice-to-have - it's a requirement.

Challenge 3: Building While Sick and Running a Gym

Problem: Got sick during development week.

Solution: Kiro made part-time development possible:

• Short vibe coding sessions when tired
• Spec-driven development when too foggy to think deeply
• Steering docs prevented mistakes
• Hooks caught errors I would've missed

I built more while sick with Kiro than what a team could traditionally make.

Challenge 4: Hardware + Software Integration

Problem: ESP32 firmware talking to Node.js backend reliably.

Solution:

• Defined API contract in steering docs FIRST
• Built both to the same contract
• Tested with curl before connecting hardware
• Hardware and backend integrated perfectly on first try

Accomplishments that we're proud of

🎯 It's Live and Working

• Deployed in production in my gym right now
• 8+ active members using NFC check-in daily
• Members asking when they can get it for their businesses
• Zero downtime since launch

💰 The Economics

• Quoted: ₱25,000 for inferior system
• Built for: ₱1,000 (25x cheaper)
• Monthly cost: ₱1,200 (kiro only - free tiers is enough for deployment)
• Competitor software: $40/month minimum

⚡ The Speed

• Core MVP: 1 week (while sick, part-time)
• vs. Traditional team: Would take 2+ months

🧠 Frontend-First Development Discovery

Discovered a Kiro workflow that:

• Eliminates integration bugs
• Enables rapid UI iteration
• Generates perfect backend contracts
• Could be valuable for other developers

🔧 Multi-Platform Mastery

Three separate platforms (embedded C++, Node.js, React, React Native) staying perfectly synchronized through steering docs and agent hooks.

👻 Ghost Detection

Built a feature competitors don't have: proactively detecting members who paid but stopped coming. One saved member pays for the entire system.

✅ Real Validation

When people who SEE it want to BUY it—that's product-market fit.

What we learned

1. Frontend-First Development Pattern

Discovery: You can reverse the traditional spec-driven workflow:

• Build the UI first (what you ACTUALLY want)
• Have Kiro generate the backend spec from it
• Backend perfectly matches frontend expectations

Why it works: The frontend knows what data it needs better than any upfront spec.

2. Steering Docs Are Essential for Multi-Platform

When building across different languages/platforms, steering docs are critical.

3. Offline-First Changes Everything

In the Philippines (and many developing countries), offline capability is super important.

4. One Person + Kiro = Dev Team Leverage

What would take a traditional team 2 months, I built in 1 week with Kiro - while sick and running a gym.

Key insight: Kiro doesn't just make you faster - it makes part-time, fragmented development viable.

5. Build for YOUR Use Case First

Because I'm the user (gym owner), I built exactly what I needed. No feature bloat. No enterprise complexity. Just what small gyms actually need.

Result: Other people immediately recognized the value.

6. Agent Hooks Prevent Mistakes

Setting up hooks to validate consistency across platforms caught dozens of potential bugs before they made it to production.

7. The Philippines Market Needs Different Solutions

Global SaaS often assumes:

• Stable internet ✗
• Reliable power ✗
• Credit card payments ✗
• English-speaking users ✗

Building for the local context created a better product.

What's next for GymOS

Immediate (Next 3 Months)

• Deploy to 5 early adopter businesses (already have inquiries from members)
• Gather testimonials and ROI data (how many ghost members recovered?)
• Add SMS/email reminder system for expiring memberships
• Create installation guide for self-deployment

The Scaling Advantage

With Kiro's Frontend-First Development, I can customize and deploy for each customer in 1-2 weeks - faster than competitors can close a sale.

Traditional deployment: 2-3 months per customer With Kiro: 1-2 weeks per customer

That's the competitive moat.

Built With

• kiro
• react
• react-native