I Sold 2 of My Apps. Here's What Actually Happened.

February 2026

Most indie developers never think about selling their apps. I didn't either — until I realized some of my apps had more value to someone else than they did to me.

In 2025, I sold two React Native apps through Flippa: AIVidly (an AI video creator) and Rhava (a Bible app that became Bibleily). Neither sale was some brilliant strategic move. The honest truth? I couldn't grow them.

Here's the real story.

Table of Contents

Why I Sold

I didn't sell because I had some clever exit strategy. I sold because I was stuck.

Running multiple apps simultaneously is real work. Every app needs iOS updates, bug fixes, user support, and marketing to keep growing. When you're a solo developer with a bunch of apps, you're constantly deciding where to spend your limited time.

Both AIVidly and Rhava hit the same wall: I couldn't figure out how to grow them.

My main strategy was ASO (App Store Optimization) — trying to rank for the right keywords, tweaking screenshots, optimizing descriptions. But ASO is incredibly competitive. For both apps, I was trying to outrank established players with bigger budgets and more reviews.

At some point, I had to be honest with myself: these apps needed someone with different skills (or resources) than I had. Selling wasn't giving up — it was being realistic.

AIVidly: Too Expensive to Maintain

AIVidly was an AI video creator app. Users could describe a video concept and AI would generate video content. I built it in late 2024 using React Native.

The Problem

AI video generation is expensive. Like, really expensive. Every video a user generated cost me real money in API calls. And the economics just didn't work at the scale I was operating at.

On top of that, I couldn't grow the user base enough to make the revenue cover the costs. ASO wasn't working — there were bigger apps with more reviews dominating the search results. I didn't have the marketing budget to do paid acquisition.

Why I Listed It on Flippa

I wasn't sure anyone would want it, honestly. But the app had a working product, a React Native codebase, and it was in a hot market (AI video). I figured someone with more resources — a bigger marketing budget, better infrastructure for video processing — could actually make it work.

The Technical Foundation

The app itself was solid technically:

// Core architecture - clean separation that made handoff easier
const VideoGenerationService = {
  async generateVideo(prompt: string, style: VideoStyle): Promise<VideoJob> {
    const job = await api.createVideoJob({
      prompt,
      style,
      duration: 30,
      quality: 'hd'
    })
    return this.pollForCompletion(job.id)
  },
  
  async pollForCompletion(jobId: string): Promise<Video> {
    const result = await api.getJobStatus(jobId)
    if (result.status === 'completed') return result.video
    if (result.status === 'failed') throw new Error(result.error)
    await new Promise(resolve => setTimeout(resolve, 2000))
    return this.pollForCompletion(jobId)
  }
}

What I Learned

• Expensive infrastructure is risky for indie devs. If every user interaction costs you money, you need serious volume or premium pricing to survive.
• ASO alone isn't a growth strategy. I leaned too hard on organic App Store discovery and it wasn't enough.
• A good codebase has value even if the business isn't thriving. Buyers care about the technical foundation, not just revenue.

Rhava → Bibleily: Zero Users, Can't Compete

Rhava was a Bible study app I built. Clean design, offline reading, personal notes, no ads. I thought the "no ads" angle would be a differentiator.

The Problem

The Bible app space is brutally competitive. There are massive apps with millions of users, and ASO was basically impossible. I was trying to rank for keywords that apps with thousands of reviews already dominated.

The result? Basically zero users. I couldn't get any traction no matter what I tried.

Listing on Flippa

I listed Rhava on Flippa figuring that even though I couldn't grow it, the app itself was well-built and the buyer might have an audience or marketing channel to bring to it.

It sold. The buyer renamed it Bibleily and integrated it into their existing portfolio of Christian apps. They had the distribution channels I didn't.

What I Learned

• A good product with no distribution is worth very little. You can build the cleanest Bible app in the world, but if nobody finds it, it doesn't matter.
• Sometimes buyers have what you lack. The buyer had marketing channels and an existing user base. That's what Rhava needed — not more features.
• Niche markets need niche distribution. Generic ASO doesn't work when you're competing against established players.

The Flippa Experience

Both apps were sold through Flippa. Here's what that was actually like:

Creating the Listing

You list your app with:

• Description of what it does
• Technical details (tech stack, architecture)
• Any revenue/user data you have
• Screenshots and demo
• Asking price

The Process

I won't pretend it was some smooth, professional acquisition process. Flippa is a marketplace. You list, people browse, some ask questions, and if someone's interested, you negotiate.

What worked:

• Being honest about where the apps were at (including the growth problems)
• Having clean, well-documented code
• Being responsive to buyer questions
• Having proper App Store assets and accounts ready for transfer

What was annoying:

• Lots of tire-kickers who ask questions and disappear
• Lowball offers
• The process takes longer than you'd think

The Unexpected Connection

Here's the coolest part: through selling AIVidly on Flippa, I found my current partner for VidNotes. We connected during the sale process, realized we had complementary skills, and ended up working together on a new project instead. Sometimes selling an app leads you somewhere you didn't expect.

What Makes Apps Actually Sellable

After going through two sales, here's what I think actually matters to buyers:

1. Clean Technical Foundation

Buyers want apps they can build on, not apps they need to rewrite.

// Architecture that buyers can quickly understand
src/
  components/     // Reusable UI components
  screens/        // Screen-level components
  services/       // API and business logic
  utils/          // Pure utility functions
  types/          // TypeScript definitions

What helps:

• TypeScript implementation
• Clean component architecture
• Well-documented API integrations
• Proper error handling
• Environment-based configuration

2. Clear Market Position

Apps that solve specific problems for specific people are easier to value.

"AI video generation for mobile content creators" is a clear pitch.

"Social media productivity tool" is not.

3. Growth Potential the Buyer Can Unlock

Buyers aren't just buying what you have — they're buying what they could turn it into with their resources. If a buyer has marketing channels, a user base, or infrastructure you don't have, your app is worth more to them than to you.

4. Simple, Transferable Business Model

Complicated pricing tiers and manual processes scare buyers. Simple subscription or one-time purchase models are easier to transfer and scale.

Technical Due Diligence

Buyers will look at your code. Here's what they check:

Code Quality

// What buyers want to see:
// 1. Clear component structure
interface UserProfileProps {
  user: User
  onEdit: () => void
}

export const UserProfile: React.FC<UserProfileProps> = ({ user, onEdit }) => {
  // ...
}

// 2. Proper error handling
const useApiCall = (url: string) => {
  const [data, setData] = useState(null)
  const [error, setError] = useState<Error | null>(null)
  
  useEffect(() => {
    fetch(url)
      .then(response => {
        if (!response.ok) throw new Error(API call failed: ${response.status})
        return response.json()
      })
      .then(setData)
      .catch(setError)
  }, [url])
  
  return { data, error }
}

// 3. Environment-based configuration
const config = {
  apiUrl: process.env.EXPO_PUBLIC_API_URL,
  apiKey: process.env.EXPO_PUBLIC_API_KEY,
}

Documentation

A good README makes a huge difference during the sale process:

# App Name

## Setup
- Prerequisites
- Installation steps
- Environment configuration

## Architecture
- High-level overview
- Key dependencies
- Data flow

## Development
- Running locally
- Testing procedures
- Build process

Security Review

Buyers check:

• API key management (not hard-coded)
• User data handling
• Authentication implementation
• Data storage security

The Emotional Side of Selling

Selling apps you built is emotionally weird. Here's what I experienced:

Before: A mix of "is my code good enough?" and "am I giving up?"

During: Anxiety about the negotiation process. Second-guessing the price. Worrying about what happens to the app after the sale.

After: Relief that someone else handles support and maintenance. Some regret about "what if I'd just figured out the marketing." And genuine validation that someone thought what I built was worth paying for.

What helped me: Viewing the sale as a realistic assessment, not a failure. I built something someone wanted to buy. That's not nothing.

The Unexpected Upside

Selling those two apps freed up my time and mental energy to focus on what I'm actually excited about: VidNotes and my other active apps.

It also taught me that my biggest weakness as an indie developer isn't building — it's growing. I need to get better at marketing skills I can actually execute on: App Store ads, content marketing, building in public. ASO alone isn't enough.

The Flippa connection that led to my VidNotes partnership was completely unexpected. Sometimes the best outcomes come from admitting what's not working and making a change.

What I'd Do Differently

Think About Distribution Before Building

Both AIVidly and Rhava had the same fundamental problem: no distribution strategy beyond ASO. Next time, I want to know how I'll reach users before I start building.

Track Metrics From Day One

When listing on Flippa, buyers ask about metrics. Having clean analytics from launch makes the sale process smoother and can increase your valuation.

Build Better Documentation Earlier

I documented code for the sale, but I should have been documenting for myself from day one. Good docs make your own development faster too.

Don't Wait Too Long to Sell

I held onto both apps longer than I should have, hoping I'd figure out the growth problem. Sometimes it's better to sell while the market is hot rather than waiting for a turnaround that might not come.

Building Your Next App with Exits in Mind

I'm not saying you should build every app to sell. But building with potential exits in mind makes you a better developer:

// Architecture that buyers appreciate
export const AppFoundation = {
  api: './services/api',
  auth: './services/auth',
  storage: './services/storage',
  config: './config/environment',
  components: './components',
  types: './types',
  utils: './utils',
  hooks: './hooks'
}

Practices that help whether you sell or not:

When to Sell vs Keep Growing

Consider selling when:

• You can't figure out how to grow the app
• Maintaining it takes more time than the revenue justifies
• Someone else could serve users better with their resources
• You want to focus on other projects

Keep growing when:

• You enjoy working on the app
• You have clear ideas for growth you haven't tried
• Revenue is trending up
• The app aligns with your long-term goals

The Ship React Native Connection

Both AIVidly and Rhava were built before Ship React Native existed. But the lessons from selling them directly influenced what I put into Ship RN:

• Clean architecture patterns that anyone can understand
• Documentation standards that help during handoffs
• TypeScript throughout for code quality
• Environment management for deployment
• Testing foundations for reliability

These practices make your apps better whether you keep them or sell them.

Selling apps taught me more about what I'm bad at (marketing) than what I'm good at (building). And that self-awareness has been more valuable than the sale prices.

Whether you sell or keep growing, be honest with yourself about where you're stuck. Sometimes the smartest move is admitting what's not working and trying something different.