The atlas.core story. A personal need, seven broken apps, and what it actually takes to build and ship a SaaS product alone.
In January 2025, I started building atlas.core — a health and fitness platform that tracks training, nutrition, hormones, recovery, and AI coaching in one system. Web and iOS. Subscription billing. Role-based access for trainers and clients. Bilingual (EN/PT).
I built it alone. No co-founder, no agency, no outsourced team. It's live in the App Store right now.
This is the story of how that happened — the real reason, the architecture decisions, the tools, and the parts nobody tells you about shipping solo.
The honest answer: I needed it for myself.
I've been on a weight loss journey for the better part of a year. Anyone who's done this seriously knows: it's not just about calories. It's hormones, sleep, training load, recovery, macros, body composition, blood work — and all of it interacts with everything else.
I was using seven different apps. One for workouts. One for food logging. One for weight tracking. One for sleep. One for blood work. One for habit tracking. One for notes. My data was scattered across all of them. Nothing talked to anything else. I couldn't see the full picture because the full picture didn't exist in any single place.
I looked for a solution that did it all. Couldn't find one. Every app was good at one thing and useless at the rest. The ones that tried to do everything were bloated, generic, and designed for a different kind of user.
So I decided to build it. The logic was simple: if it works for me, I'll use it every day. If it works for me and it's good, I'll let other people use it too.
I didn't set out to build a startup. I set out to solve a problem that was driving me crazy. The product came from the frustration.
There was a second reason. I'd spent five years on the revenue side of B2B SaaS — outbound systems, SDR teams, pipeline, closing. I understood the business pressure. But I'd never shipped software. Building atlas.core closed that gap. It made me the kind of operator who's been on both sides of the wall.
The insight: most people either sell or build. The ones who do both move differently. They see the full loop.
Every solo builder's first trap is over-engineering the stack. I wanted to move fast and ship to web and iOS from one codebase. Here's what I chose:
The key decision was Capacitor over React Native. React Native would have given me better native performance, but it would have forced me to maintain two mental models — web and native — simultaneously. Capacitor let me write one app and deploy it to both web and iOS. For a solo builder, that tradeoff is worth it.
I used AI throughout the build. Not as autocomplete. As a decomposition partner.
Here's the difference: autocomplete suggests the next line. A decomposition partner helps you break a vague goal ("add role-based access") into concrete implementation steps, catch edge cases before they become bugs, and reason through architecture tradeoffs.
Specific examples:
The result: I shipped features at a pace that felt like a small team, not a solo dev. The AI didn't replace judgment — it accelerated the parts between judgment calls.
Building the app was the easy part. Getting it through Apple's review process was the hard part.
Apple rejected the first submission. The reason: "Insufficient content." The app worked, but Apple's reviewer felt the onboarding didn't demonstrate enough value before asking for a subscription. I had to:
The second submission was approved. Total time from first submission to live: 11 days. Eleven days of waiting, refreshing App Store Connect, and wondering if I'd missed something obvious.
The live product today:
Start with mobile-first. I built the web app first and adapted it for mobile. This meant I was constantly retrofitting touch interactions, navigation patterns, and viewport constraints. If I started again, I'd design for the phone screen first and scale up.
Ship the MVP faster. I spent too long on role-based access before validating that anyone wanted the product. The RBAC system is excellent — but it would have been equally excellent built three months later, after I had paying users.
Automate the release pipeline earlier. Manual builds for web and iOS (deploy + TestFlight) eat hours every release cycle. I should have set up CI/CD in week two, not month three.
Building atlas.core changed how I think about revenue work. When you've shipped code, you stop saying "the engineering team should..." and start saying "the constraint is..." You understand why estimates slip. Why scope creep is expensive. Why the gap between "it works on my machine" and "it's live in the App Store" is a canyon.
That context makes me a better operator. Not because I'm going to build every product I sell. But because I've been on both sides of the wall, and I can translate between them.
That's the thesis: sell and build are not separate skills. They're two views of the same system.
Try atlas.core or get in touch.
Visit atlas.core →