Recoup: Get Your Money Back

Turn duplicate charges and cancelled subscriptions into an editable complaint letter. Track your claim, follow up, and record the outcome—all from Android or iOS.

Comment

Inspiration

A duplicate charge or a subscription that keeps billing after cancellation can leave someone with two problems: money missing and no clear next step. Writing to the company means gathering facts, explaining what happened, and remembering to follow up. A blank email does not help with any of those tasks.

I built Recoup to connect those steps in one place: describe the problem, review a letter, and track the claim. The goal is to make an everyday complaint easier to organize and act on, while keeping the person in control of what they send.

What Recoup does

Recoup starts with a situation rather than a blank document. Guided questions collect the company, amount, dates, and relevant details. Users choose the letter language separately from the app language, then review their answers before generating the letter.

The finished letter remains editable. Sending guidance helps users prepare the recipient, attachments, and next steps. Users decide what to send and send it themselves; the app does not submit a complaint on their behalf.

After sending, users can mark the claim as sent and follow its timeline. The saved letter, status, and next check-in stay together. When the matter is resolved, the user records the outcome and can create a result card.

The built-in demo lets people explore the workflow with fictional information. The claim and refund shown in our video are demo examples, not a real recovered payment.

How I built it

Recoup is published on Android and iOS and uses Kotlin Multiplatform and Compose Multiplatform. Common code contains the guided claim flow, validation, claim state transitions, repositories and interfaces, state management, navigation, and feature UI.

The architecture separates pure domain modules from presentation and data implementations. The shared application assembles the navigation graph and dependencies with Koin, while Android and Swift executables own platform lifecycle and native SDK integration. Room provides local persistence.

Real-account letter generation uses a protected Firebase Cloud Function backed by DeepSeek. Firebase Authentication and App Check protect the callable service. The iOS integration calls it through a Swift bridge, while Android uses its native integration. The template letter shown in the video is reserved for the built-in demo; it does not demonstrate a live AI response.

RevenueCat connects the credit and subscription experience to native billing on each platform. Shared billing interfaces keep purchase state out of the claim rules and allow the UI to respond to changing access.

A development loop built around features

I wanted to work on a feature without building the entire application. Recoup includes independently runnable authentication and claims samples, backed by deterministic fixtures. The samples give the feature a small, repeatable environment on Android and iOS.

Architecture checks verify dependency direction. Isolation checks examine the resolved sample dependency graph and prevent samples from reaching production data, the application root, or another feature. The aim is to make module boundaries verifiable instead of relying on directory names.

The MVI approach separates user actions, state transitions, and one-shot effects. This makes a flow easier to inspect: an answer changes state, while navigation is handled as an effect with the appropriate lifecycle.

I documented these decisions in a three-part Medium series and shared daily development progress on X. The articles use a separate public reference project to demonstrate the architecture; its benchmarks are not Recoup production benchmarks.

Monetization with RevenueCat

The first claim is free. For occasional use, users can purchase a pack of claim credits. For repeated use, Recoup Pro offers a subscription route. This gives people a choice that matches how often they need the product.

RevenueCat manages offerings, purchases, restoration, and subscription access. Pricing is displayed through the store offering. The model combines a useful first experience with an occasional purchase option, without requiring every user to start a recurring subscription.

Challenges

  • Turning answers into a coherent letter. A generated letter must stay connected to the facts the user reviewed. Structured inputs, validation, and an editable result keep that review central to the workflow.
  • Keeping claim progress understandable. A saved draft, a sent claim, a waiting response, and a resolved outcome need distinct states and a clear timeline.
  • Separating app language from letter language. The user's preferred interface language may differ from the language needed by the recipient.
  • Integrating native services across platforms. Authentication, cloud calls, and billing require platform implementations even when the claim experience is shared.
  • Making architecture testable. Declared dependencies alone do not establish sample isolation; the resolved graph must also respect the boundaries.

What I learned

The useful output is more than a letter. People need a manageable sequence of decisions: confirm the facts, review the wording, send it, and know when to check back.

I also learned how much a small feature sample can improve the development loop. Keeping fixtures, domain rules, and UI boundaries explicit makes it easier to inspect behavior and explain the design publicly.

What's next

I want to gather feedback from real users, improve the clarity of scenario questions and follow-up guidance, and expand the claim workflow while keeping Android and iOS behavior consistent.

Recoup provides educational information and drafting tools, not legal advice or a guarantee of a refund. Its role is to help users prepare and track their own requests.

Draft the letter. Track the claim.

Built With

Share this project:

Updates

Submission history