How I Built 10+ Apps with React Native (What I Learned)

February 2026

I started teaching myself to code in 2017. Navigation was broken. Animations stuttered. The docs were incomplete.

Today, I've shipped over 10 React Native apps — some profitable, some sold, some retired, and a couple I pretend don't exist.

Here's everything I learned the hard way.

Table of Contents

The Journey: 2017 to 2026

2017: The Beginning

Downloaded React Native. Spent days trying to get navigation working. Almost quit multiple times.

First thought: "This is impossible."

2018-2019: The Struggle Years

• Built apps that never shipped
• Spent more time fixing builds than adding features
• Questioned every technology choice

2020-2021: The Learning Years

• Started understanding mobile-specific patterns
• Shipped early apps like Deo (personal task/note management)
• Realized React Native was finally getting mature enough to build real things

2022-2023: Building the Portfolio

• Started shipping focused utility apps
• Built Coldsmith, MoonLatte, TeleprompterX
• Began understanding what makes apps stick (and what doesn't)

2024-2026: AI Era + Exits

• Built AIVidly (late 2024), sold it in 2025 on Flippa
• Sold Rhava/Bibleily in 2025 on Flippa
• Shipped VidNotes, YapperX, BeatAI, FIFTN, Newsletterytics
• Started distilling lessons into Ship React Native

The Early Apps: Learning by Failing

The Fitmate App (Early days)

The idea: Fitness app with social features.

The reality: Overcomplicated mess with way too many screens.

// My actual early code (don't do this)
class FitmateApp extends React.Component {
  constructor(props) {
    super(props)
    this.state = {
      user: null,
      workouts: [],
      friends: [],
      notifications: [],
      settings: {},
      theme: 'light',
      isLoading: false,
      hasError: false,
      errorMessage: '',
      // ... way too many state variables
    }
  }
  
  // Hundreds of lines of methods in one component
}

What I learned:

• Complex state management matters from day one
• Navigation architecture is critical
• An MVP should be minimal. I built an MBP (Minimum Bloated Product).

Result: Never shipped. Abandoned.

Countdown Nuts

The idea: Countdown timer app.

The reality: Didn't find an audience.

What I learned:

• Start with one core feature
• Validate demand before overbuilding
• "I think this would be cool" isn't validation

Result: Retired.

The Pattern of Early Failures

Every early app had the same problems:

• Too many features for an MVP
• No clear user in mind
• Built what I thought was interesting, not what people needed
• Zero marketing plan

Finding My Rhythm

Deo (Personal Task/Note Management)

Deo was a personal app — I built it because I needed a simple way to manage tasks and notes. It wasn't designed to make money. But building something for myself taught me the most important lesson:

Solve your own problems first.

When you're the user, you know exactly what's annoying, what's missing, and when something feels right. You don't need user interviews because you ARE the user.

Coldsmith (Cold Exposure Tracking)

The idea: Track cold showers, ice baths, and breathing exercises.

The context: I was doing Wim Hof method and couldn't find a good app to track my cold exposure sessions.

This was my first app that clicked with a real (if tiny) niche. Cold exposure enthusiasts are passionate people. They want to track their progress, see their streaks, and push their limits.

What went right:

• Solved my own problem
• Tiny but passionate niche
• Simple core feature done well

What I learned:

• Small niches can work if the users are passionate
• Not everything needs to be a massive market
• Building for yourself creates authentic products

MoonLatte (Caffeine Tracking)

The idea: Simple caffeine tracker without the health app bloat.

Why it worked: Every caffeine tracking app I tried was either part of a massive health suite or had terrible UX. I wanted something minimal.

What I learned:

• "Minimal" is a feature, not a limitation
• People are willing to pay for simplicity

The Apps That Worked

Newsletterytics (Beehiiv Analytics)

What it does: Deeper analytics for Beehiiv newsletter creators.

Why it works: Beehiiv's built-in analytics are basic. Creators want more insights into their subscriber behavior.

Key decision: I started Beehiiv-only instead of trying to support every newsletter platform. That focus let me build deeper integration.

TeleprompterX

What it does: Teleprompter for video creators, especially iPad users.

Differentiator: Apple Watch control, PiP mode, voice control.

Most teleprompter apps are phone-first afterthoughts. TeleprompterX was built iPad-first, which resonated with video creators.

YapperX (Voice Memos → Tweets)

What it does: Capture quick voice thoughts and turn them into shareable content.

Why it matters: The gap between having a thought and capturing it is where ideas die.

Technical foundation:

const useVoiceMemo = () => {
  const { recordAudio } = useAudioRecording()
  const { transcribeAudio } = useWhisperAPI()
  
  const createMemo = async () => {
    const audioUri = await recordAudio()
    const transcription = await transcribeAudio(audioUri)
    return { audioUri, transcription }
  }
  
  return { createMemo }
}

VidNotes (Video Notes)

What it does: Take notes on videos with AI summarization.

Why I'm focused on it: Video content is exploding but tools for processing it are still desktop-first. VidNotes is my main project right now, and the one I'm most excited about.

BeatAI (AI Music Practice Coach)

What it does: AI-powered music practice companion that helps you stay accountable and improve.

Why it's different: Most music apps are about listening. BeatAI is about practicing.

FIFTN (Focus Timer)

What it does: Focus timer with smart app blocking.

The niche: Deep work enthusiasts who want intentional technology use.

The Sold Apps

• AIVidly (AI video generation) — Built late 2024, sold 2025 on Flippa. Couldn't grow it, video generation was too expensive to maintain.
• Rhava → Bibleily (Bible app) — Sold 2025 on Flippa. Couldn't compete in ASO, basically zero users.

Both taught me that building is the easy part. Growing is where I need to improve.

What I Wish I Knew in 2017

1. Start with Revenue, Not Downloads

2017 me: "If I build it, they will come."

2026 me: "If they won't pay, they don't really want it."

My early apps had zero monetization strategy. Plan how users will pay from day one.

2. Solve Your Own Problems

Apps that failed: Solved problems I imagined other people having.

Apps that worked: Solved my daily frustrations.

• Deo: I needed simple task management
• Coldsmith: I needed cold exposure tracking
• MoonLatte: I wanted caffeine tracking without bloat
• YapperX: I wanted to capture voice thoughts quickly

3. Simple > Complex (Always)

2017 me: "More features = better app"

2026 me: "One feature done perfectly beats 10 features done poorly"

Feature creep killed my early apps. The Fitmate App had workout tracking, social features, nutrition logging, progress photos, achievements... everything was mediocre.

Better approach: Do one thing extremely well, then expand.

4. Technical Debt Compounds

2017 me: "I'll refactor later"

2026 me: "Clean code from day one, or pay forever"

My early apps became unmaintainable:

• Week 1: Fast progress (spaghetti code works)
• Week 4: Slowing down (debugging takes longer)
• Week 8: Paralyzed (afraid to change anything)

5. Distribution is Everything

2017 me: "Great apps promote themselves"

2026 me: "Great apps with bad distribution fail"

I learned this the hard way with AIVidly and Rhava. Both were solid products that nobody found. ASO alone isn't enough. I need to get better at marketing — App Store ads, content marketing, building in public.

Technical Lessons: Code That Actually Works

1. State Management Evolution

2017: Component state for everything

this.setState({ 
  user, workouts, friends, settings, notifications,
  theme, loading, error, cache, preferences 
})

2019: Redux (too complex for most apps)

const workoutReducer = (state = initialState, action) => {
  switch (action.type) {
    case 'ADD_WORKOUT_REQUEST':
      return { ...state, loading: true }
    case 'ADD_WORKOUT_SUCCESS':
      return { ...state, loading: false, workouts: [...state.workouts, action.payload] }
    // ... 50 more cases
  }
}

2026: Zustand (perfect for indie apps)

const useWorkoutStore = create((set) => ({
  workouts: [],
  addWorkout: (workout) => set((state) => ({ 
    workouts: [...state.workouts, workout] 
  })),
}))

2. Navigation Evolution

2017: React Navigation v1 (nightmare)

const AppNavigator = StackNavigator({
  Home: { screen: HomeScreen },
  Profile: { screen: ProfileScreen }
}, {
  mode: 'modal', // Broke on Android
  headerMode: 'screen' // Broke on iOS
})

2026: Expo Router (finally!)

app/
  (tabs)/
    index.tsx        // /
    profile.tsx      // /profile
  login.tsx          // /login
  settings/
    index.tsx        // /settings
    [id].tsx         // /settings/123

3. Backend Evolution

2017-2020: Custom Express servers

• Complex deployment, expensive, constant maintenance

2020-2022: Firebase (vendor lock-in)

• Easy to start, hard to customize, expensive at scale

2023-2026: Convex (great for React Native)

• Real-time subscriptions
• Edge functions
• Document-level access control

4. Testing Evolution

2017: No tests

"Testing is for people who don't know how to code" (I was wrong)

2019: Over-testing

100% coverage, took longer to write tests than features

2026: Strategic testing

describe('useWorkoutTracking', () => {
  it('calculates weekly progress correctly', () => {
    const workouts = [
      { date: '2026-02-01', duration: 30 },
      { date: '2026-02-03', duration: 45 }
    ]
    const progress = calculateWeeklyProgress(workouts)
    expect(progress).toEqual({ total: 75, average: 37.5 })
  })
})

Business Lessons: Apps That Actually Make Money

1. Monetization Models

Ads (don't work for most indie apps):

• Need massive user numbers
• Terrible user experience

Freemium (works for utility apps):

• Free version solves a real problem
• Premium adds convenience
• Conversion varies a lot by niche

Subscription (works for ongoing value):

• Monthly/annual recurring revenue
• Must provide continuous value

2. Pricing

My evolution:

• 2020: Race to the bottom with cheap one-time purchases
• 2026: Value-based pricing with subscriptions

Higher prices attract better customers who actually use the app.

3. Marketing (My Weak Spot)

This is where I'm honest: marketing is my biggest weakness. I relied too heavily on ASO, and it wasn't enough for several apps.

What I'm learning to do better:

• Building in public on Twitter
• Content marketing
• App Store ads
• Community engagement

What didn't work for me:

• Pure ASO in competitive categories
• Hoping for organic discovery
• Building and praying

4. App Store Optimization

What matters most:

The Patterns That Emerge

After 10+ apps, clear patterns emerge:

Successful Apps:

Failed Apps:

What's Next: The 2026 Playbook

Based on 8+ years of experience:

The Stack That Works

• Framework: Expo SDK 55+
• Navigation: Expo Router
• State: Zustand
• Backend: Convex
• Payments: RevenueCat
• Analytics: PostHog
• AI: OpenAI APIs via edge functions

The Development Process

The Business Model

• Freemium: solve the problem for free, add convenience for pay
• Monthly/yearly subscription
• Focus on annual plans for better retention

Where I Need to Improve

• Marketing. Seriously, marketing.
• Learning App Store ads
• Building an audience before launching
• Not relying solely on ASO

The Real Secret

After 10+ apps and 8+ years of React Native:

Success isn't about perfect code or brilliant ideas. It's about shipping consistently and learning from what doesn't work.

My most technically impressive apps aren't my most successful ones. The apps that worked are the ones that solved real problems for real people — including me.

The pattern:

That's it. No secret frameworks, no perfect architecture.

Just solving real problems, one app at a time. And getting better at telling people about it.

Want to skip the 8 years of boilerplate? Ship React Native includes the patterns, components, and infrastructure I wish I had in 2017.

Get Ship React Native and start with the foundation it took me 10+ apps to build.

Written by Paweł Karniej, indie developer since 2017. Currently focused on VidNotes and running Silpho app studio from Białystok, Poland. Follow @thepawelk for real-world mobile dev updates.