Bad Poochy

Bad Poochy is a dog photo roasting app that turns innocent pet pictures into brutally funny, shareable roast cards. Basically, a comedy club for dogs who never asked for it.

Comment

Inspiration

Bad Poochy was born in the least glamorous way possible. I was sitting on the toilet when the idea suddenly popped into my head: what if there were an app that looked at a photo of a dog and absolutely roasted it? That was basically it. No brainstorming session, no market research, no inspirational founder moment. Just a toilet and an unnecessarily judgmental idea. What made me keep thinking about it was how naturally people already do this with dogs. One strange expression and suddenly the dog looks unemployed, divorced, guilty of tax fraud, or like it has been banned from three Petcos. So I started wondering how far that idea could go. Instead of giving every photo the same generic joke, Bad Poochy could treat the dog like a character and the photo like evidence. Different judges could look at the same dog and come to completely different conclusions. From there, the idea grew into a full comedy experience with different judges, personalized roasts, visual presentation, and shareable roast cards. The original idea was extremely simple: upload a dog, receive emotional damage. Well, “emotional damage”.

What it does

Bad Poochy turns a dog photo into a personalized roast. A photo is selected, framed with a custom crop tool, and sent to one of Bad Poochy's judges. Each judge has a different personality, point of view, and style of comedy, so the same dog can be interpreted very differently depending on who gets the case. The app analyzes the actual photo instead of simply dropping a dog into a prewritten joke. Expressions, poses, surroundings, and other visible details can all become part of the roast. After a short loading sequence, the roast appears as a finished result rather than a block of generated text. From there, it can be turned into a Bad Poochy roast card combining the dog's photo, the judge, the roast, and the visual identity of the app. The card can then be saved or shared. That part became increasingly important while building the app. The goal is not just to make somebody laugh inside Bad Poochy. The goal is to make something funny enough to escape the app and end up in texts, group chats, social posts, and conversations. Bad Poochy also uses a credit system for additional roasts, with purchases handled entirely through RevenueCat.

How I built it

Bad Poochy is built with React Native, TypeScript, and Expo, allowing the same product to run across iPhone, iPad, Android phones, and Android tablets. React Navigation manages the experience from the landing screen through judge selection, photo selection, cropping, loading, results, purchasing, and sharing. Supabase handles the backend side of the app, including user access and credit information. Roast generation runs through a Supabase Edge Function that sends the selected dog image and judge instructions to OpenAI and receives structured roast data back. The judge system became one of the most important parts of the app. Instead of using one general prompt and changing a few words, each judge was developed around a different personality, voice, structure, and comedic logic. The idea was to make the system feel less like one text generator wearing different hats and more like a cast of characters who genuinely disagree about the dog in front of them. RevenueCat handles purchases for the credit system. A surprising amount of development also went into everything surrounding the roast itself. Expo Image Picker handles photo selection, while Expo Image Manipulator supports the custom cropping workflow. I built a crop interface that allows the frame to move and resize while changing naturally between square and 4:3 proportions. For sharing, the app creates a complete visual roast card. React Native View Shot captures the card as an image, Expo Media Library saves it to the device, and Expo Sharing connects it to the native sharing experience.

Challenges I ran into

One of the biggest lessons from building Bad Poochy was discovering that generating the joke was only one part of the problem. The app has a very specific visual identity, and that identity had to survive completely different screen sizes. Something that looked right on an Android phone could feel completely different on an iPad. Text that fit perfectly in one roast card could run into the top of an iPhone screen when the roast became longer. Even small visual elements could look noticeably wrong when moved to another device.

The crop screen became its own design problem. I did not want a generic fixed crop box. The frame needed to move freely, resize naturally from its corners and edges, and change between square and 4:3 proportions without allowing shapes that would break the visual system later. The share card created another challenge because roast length is unpredictable but the composition is not. Typography had to adjust dynamically while still making every card look like the same product. Then there was the less glamorous side of shipping an actual mobile app: authentication, purchases, signing credentials, provisioning profiles, Android signing keys, App Store requirements, and native dependencies.

Accomplishments that I'm proud of

I am proud that Bad Poochy became an actual product instead of remaining a funny idea I had on a toilet. The complete experience now works across iPhone, iPad, Android phones, and Android tablets. The crop interaction, loading sequence, roast result, purchase system, and share card all had to feel like parts of the same thing rather than a collection of technical features. I am especially happy with the sharing experience. The final output is not just text copied from a response. It becomes a designed Bad Poochy card that gives the joke a second life outside the app. I am also proud of how much personality survived the technical process. It would have been very easy for Bad Poochy to become another app where a photo goes in and generated text comes out. The judges, visual presentation, timing, language, and absurd seriousness are what make it Bad Poochy. After a lot of testing, debugging, certificates, store requirements, and several moments when mobile development clearly had a personal issue with me, Bad Poochy reached a successful production iOS build and App Store Connect submission.

What I learned

The biggest thing I learned is that a funny idea is not automatically a funny product. Timing matters, presentation matters, the crop matters, the loading screen matters, and the size of the roast text matters. Even where a button sits can change whether the experience feels polished or cheap. I also learned that designing for multiple mobile devices is very different from simply making an interface responsive. A phone and a tablet are not just differently sized rectangles. The visual hierarchy, spacing, balance, and relationship between elements can change completely. On the product side, I learned to think beyond the first successful roast. A roast can be funny once, but a product needs a reason for somebody to come back, try another judge, share the result, and eventually decide another experience is worth paying for. That changed the way I thought about Bad Poochy. The roast itself is only the beginning. The real product is the loop around it.

What's next for Bad Poochy

The immediate goal is to launch Bad Poochy publicly and see what real users actually do with it. The questions that matter now are behavioral ones: Which judges make people come back? Which roasts get shared? How often does somebody generate another roast? Which kinds of photos produce the funniest results? What makes somebody decide another roast is worth paying for? Those answers will shape the next version much more than guesses made before launch. From there, I want to expand the judge system, experiment with new roast formats, improve the social sharing loop, and continue developing the part of Bad Poochy that matters most: turning one completely ordinary dog photo into something absurdly specific that somebody immediately wants to send to someone else.

Built With

  • android
  • applesignin
  • asyncstorage
  • expo.io
  • expoimagemanipulator
  • expoimagepicker
  • expomedialibrary
  • exposharing
  • googlesignin
  • ios
  • ipados
  • openaiapi
  • reactnative
  • reactnativeviewshot
  • reactnavigation
  • revenuecat
  • supabase
  • typescript
Share this project:

Updates

Submission history