Mobile / Insight
Planning Your First Mobile App
The app itself is the smallest part of the project. The plan around it decides whether it is still useful in year two.
A first mobile app is usually proposed for the wrong reason. Someone says "we need an app" when what they mean is "our customers cannot do this easily on our website" or "our field staff cannot record this while they are out." Those are different problems, and only one of them is solved by an app.
Before committing, it helps to separate the app from the system behind it. The screens a customer taps are the visible part. Underneath are accounts, data, notifications, updates and support. Most of the cost and nearly all of the long-term risk live underneath.
Decide the one job first
A useful first release does one thing well for one group of people. Not "the whole business in an app", but "let a delivery rider mark an order delivered with a photo" or "let a parent check results and pay fees".
Write the job as a sentence with a subject and a verb. If it needs the word "and" more than once, it is probably two releases. Narrowing the first version is not a lack of ambition; it is how the team learns what the app is like to use before the expensive decisions are locked in.
Then name the user. An app for staff and an app for customers have different expectations: staff can be trained, customers cannot. Staff tolerate a dense screen if it saves time; customers expect the first screen to explain itself. Choosing one audience for release one keeps both the design and the support model honest.
The app is the smallest part
Behind a successful first release there is usually an API, an admin area, a notification path and a way to update content without shipping a new app version. If those are missing, the app becomes a frozen snapshot of last year's business rules.
- An API the app talks to. It should be the same data the office sees, not a separate copy that drifts.
- An admin area. Someone on the team needs to add a product, correct a record or answer a support question without calling a developer.
- Notifications that can be trusted. Push notifications are convenient and unreliable in equal measure. Important updates should also be visible inside the app.
- An update path. Content and prices should change without a store review cycle.
This is the part clients underestimate. A demo app can be built quickly. An app that a business runs on needs the unglamorous parts to exist before launch, not after.
Offline is a design decision, not a feature
In Nepal, connectivity varies by location, building and time of day. A delivery route may pass through areas with no usable data signal. A school may have one overloaded connection for the whole office.
Decide early what must work without a signal. For a rider, that might be viewing today's route, marking a delivery and capturing a photo, with the sync happening when the phone reconnects. For a customer app, offline probably means a clear message and a retry, not a full offline mode.
Offline support changes the architecture. It requires local storage, conflict rules and a visible sync status. Adding it later is expensive, so it belongs in the first conversation, even if it is deferred to release two.
Choose the distribution path deliberately
There are three realistic paths, and they are not interchangeable.
- Native or cross-platform app on the stores. Best reach and trust for consumer apps. Costs an annual developer account, store review cycles and a release process you must maintain.
- Internal app distributed to staff. Can be a store build with a private track, or a signed package installed directly. Faster to update, narrower audience.
- Progressive web app. A website that installs to the home screen. No store account, instant updates, but limited access to device features and weaker offline behaviour on some phones.
Choose based on who installs it and how often it changes, not on which sounds most modern. A staff tool used by twelve people does not need the same distribution as a consumer product.
Budget for year two
The launch budget is the easy number to approve. The harder question is what the app costs to keep alive.
- Operating-system updates that break behaviour on new phones.
- Store policy changes and annual account fees.
- Backend hosting, storage and notifications.
- Support when a user cannot log in at the busiest hour of the week.
- Small feature requests that arrive once people use the thing daily.
A realistic plan names who owns each of these before launch. If the answer is "the developer who built it, whenever we call", that is a support arrangement, not a plan, and it should be priced as one.
Do not over-buy the stack
It is tempting to choose the most capable framework, the most scalable database and the most elaborate infrastructure before the first user has logged in. For a first release, that is usually a way to spend the budget on problems you do not have yet.
Start with technology the team can operate. A well-understood stack with boring, reliable choices will outlast a fashionable one that nobody on the team can debug at midnight. Scalability is a property of decisions — how data is indexed, how images are served, how the app behaves when the network is slow — more than a property of a logo on the homepage.
The same caution applies to integrations. Every third-party service added in release one is another account, another key, another failure mode and another bill. Add the ones the first job genuinely needs, and leave the rest until a real workflow demands them.
Test with the people who will use it
A first release should be tested by the rider, the clerk or the parent — not only by the team that built it. Watch someone complete the main task without instructions. Where they pause, the screen is unclear. Where they ask a question, the interface is missing information. Where they find a shortcut you did not plan, you have learned something worth keeping.
Run this before launch, then again a week after. The second session is more honest, because the novelty has worn off and the work has returned to normal. A short list of fixes from that session is a better roadmap than a long list of features written in a meeting room.
Finally, decide what happens when something breaks. A support path with a named person, a response expectation and a way to report a problem is part of the product. An app that works beautifully but has no one to call at 9am on a Saturday is not finished, however clean the screens look.
A first-release checklist
- One job, one audience, written as a sentence.
- The data the app needs, and where it lives.
- The admin screen that keeps the data correct.
- What must work offline, and what can wait for signal.
- How the app is distributed and updated.
- Who supports it in month three.
- What success looks like in numbers you can actually collect.
If you can answer those seven, the build is a scoping exercise rather than a gamble. If several are blank, the next useful step is a short discovery, not a development contract. We have done both — a SaaS product and internal tools for operations — and the pattern is the same: the plan around the app decides whether it survives.
If you are weighing an app against improving your website, the answer often depends on whether the job needs a phone. Tell us the job through the contact page and we will say which one it is.
