Free template · app proposal

Mobile app development proposal template

A proposal for building an iPhone and Android app, written out in full: the journey the app is for, how it's built and why, what Apple and Google require, the running costs, weekly test builds and a phased price with optional extras. Worked through for a fictional dog-walking startup.

Sections
11
Estimate
12 lines, 216 hours
Example total
$23,760.00
Payments
30% / 30% / 40%
Proposal

PawWalk: iOS and Android app, design and build

Prepared for PawWalk

Investment
From $23,760
Timeline
12 weeks
Payments
3 stages

What you need

Today owners book walks by text and pay by bank transfer, and nobody knows where the walk is until the dog comes home. You want one app where an owner books and pays in a few taps, sees the walker live on a map during the walk, and rates it afterwards, with a simpler side of the same app for walkers.

We propose to build it for iPhone and Android together in about 12 weeks, with a test version on your phone every Friday.

How it's built, and why

  • React Native (with Expo): one codebase for iPhone and Android, so both ship together and later changes cost once, not twice
  • Firebase for sign-in, the database and push notifications, on an account in your name
  • Stripe for payments, including Apple Pay and Google Pay
  • Live location only during a walk, shared with the walker's permission and stopped when the walk ends
  • Weekly test builds through TestFlight (iPhone) and Google Play internal testing, so you try every feature on a real phone before launch

What's included

Design

  • Screen flows for owners and walkersS-1
  • Designs for every screen, on small and large phonesS-2
  • A clickable prototype you approve before the buildS-3

Owners

  • Sign-up, dog profiles and saved addressesS-4
  • Booking a walk with a time slot and a walkerS-5
  • Paying in the app, with receiptsS-6
  • Live map during the walk, and a photo when it endsS-7
  • Rating the walkS-8

Walkers

  • Accepting and declining walksS-9
  • Starting and ending a walk (which shares and stops location)S-10
  • Earnings for the weekS-11

Release

  • Testing on real iPhones and Android phonesS-12
  • App Store and Google Play listings, privacy forms and reviewS-13
  • Crash reporting and basic analyticsS-14

Not included

  • A web versionX-1
  • An admin dashboard beyond a simple bookings listX-2
  • MarketingX-3
  • App-store screenshots designX-4

What the app stores require

  • Apple and Google review every release; the first review usually takes a few days, and that wait isn't counted in the timeline
  • An in-app way to delete an account, privacy labels and a clear reason for asking for location: all included above
  • Developer accounts in your name: Apple charges $99 a year and Google a one-time $25, paid by you, so you own the listings

Investment

Priced by phase, with a 10% contingency for store feedback and device-specific fixes (only invoiced if used). The two extras are optional.

TaskHoursRateAmount
Design · 32 h$3,200.00
Screen flows, designs and prototype32$100.00$3,200.00
Owners · 110 h$11,000.00
Project set-up, builds and test distribution10$100.00$1,000.00
Sign-up, dog profiles and addresses18$100.00$1,800.00
Booking with time slots28$100.00$2,800.00
Payments with Stripe, Apple Pay and Google Pay20$100.00$2,000.00
Live map during walks24$100.00$2,400.00
Ratings and walk photos10$100.00$1,000.00
Walkers · 36 h$3,600.00
Walker side: accept, start and end walks, earnings26$100.00$2,600.00
Push notifications10$100.00$1,000.00
Release · 38 h$3,800.00
Testing on real phones and fixes24$100.00$2,400.00
Store listings, privacy forms and review10$100.00$1,000.00
Crash reporting and analytics4$100.00$400.00
Optional extras
Walker payouts with Stripe Connect24$100.00+$2,400.00
In-app chat between owner and walker20$100.00+$2,000.00
Subtotal$21,600.00
Contingency (10%)$2,160.00
Total$23,760.00

Timeline

About 12 weeks: design in weeks 1–2, building in weeks 3–10 with a test build every Friday, testing and store submission in weeks 11–12.

Payments

  1. To startOn approval$7,128.0030%
  2. Test build with booking and paymentsWeek 6$7,128.0030%
  3. Live in both storesWeek 12$9,504.0040%

Assumptions and exclusions

  • You vet and onboard walkers; the app records who they are, not whether they're suitable
  • Running costs (Firebase, maps, Stripe fees) are billed to your accounts; at launch they're usually small and grow with use
  • Not included: a web version, an admin dashboard beyond a simple bookings list, marketing and app-store screenshots design

Questions you might have

Why one codebase instead of two native apps?

For an app like this, React Native gives the same experience on both platforms for roughly half the build and maintenance cost. If a future feature needs native code, it can be added for that feature alone.

What if Apple or Google rejects it?

We fix what the reviewer asks for and resubmit; it's covered by the contingency. Rejections are usually about wording in the listing or a permission explanation, not the app itself.

Who owns the app?

You do: the code (in your repository from day one), the store listings (in your developer accounts) and all the data.

Terms

Invoices are due within 14 days. Two rounds of changes are included on the designs; work outside the agreed scope is quoted in writing before it starts. Ownership of the code and designs passes to you on final payment. We fix defects against the agreed scope free for 30 days after the app is live in both stores.

Next step

Approve below and we'll send the first invoice and book a two-hour workshop to map the owner and walker journeys.

A worked example for a fictional client. Every word and number is yours to change.

How to write each part

  1. Start with the journey that matters

    An app proposal that opens with a feature list reads like everyone else's. Open with the one journey the app exists for (book a walk, watch it live, pay) and the problem it removes. Every screen in the scope should serve that journey or be marked as an extra.

  2. Explain cross-platform or native in one paragraph

    Most clients don't know the difference and shouldn't have to. Say what you'll use and the practical reason (“one codebase, so both apps ship together and changes cost once”), and what you'd do if a feature ever needs native code.

  3. Account for the app stores

    Store review takes time you don't control, and both stores require things clients don't expect: an in-app way to delete an account, privacy labels, a reason for every permission. List them so they're in scope, and keep review waits out of your timeline.

    Put the developer accounts in the client's name. It costs them little and settles who owns the listing for good.

  4. Name the running costs

    Backend, maps, push notifications and payment fees are billed monthly and grow with use. Say they go to the client's accounts and are small at launch, so the first bill isn't a surprise and nobody expects you to absorb it.

  5. Promise test builds, not screenshots

    A test version on the client's own phone every week (TestFlight, Google Play internal testing) shows real progress and catches “that's not what I meant” early, when it's cheap to change.

  6. Price by phase, with contingency for review

    Price each part of the journey, keep a visible contingency for store feedback and device quirks, and put the nice-to-haves (payouts, chat) in an optional group the client can tick.

Questions people ask

How do I write a mobile app development proposal?

Open with the journey the app is for, then the scope as screens for each type of user, how it's built and why, what the app stores require, running costs, the timeline with test builds, a phased estimate with extras, payments, assumptions and terms. The example above follows that order.

What should a mobile app proposal include?

The problem and the main journey, scope per user type, the technology and why, store requirements (account deletion, privacy labels, permissions, developer accounts), running costs, testing on real phones, timeline, estimate, payments, exclusions and ownership.

Should I propose native or cross-platform?

For most business apps, a cross-platform framework such as React Native or Flutter builds both apps from one codebase for much less than two native apps. Native makes sense for heavy graphics, deep hardware use or platform-specific features.

How long does it take to build an app?

It depends on the screens and integrations. The example above plans 12 weeks for two user types, payments and live location; estimate your own by phase, and leave store review time out of the dates you promise.

Who owns the app after it's built?

Say it in the terms. Usually the client owns the code and designs on final payment, and the store listings live in developer accounts in their name from the start.

Can I download this app proposal template?

Yes: download it as Markdown for Google Docs, Notion or Word, or print it to PDF. Or open it in Devposal and send it as a link your client approves on their phone.

Related