Offline Functionality: What Should Your App Do Without Internet Access?
An app should never lose what the user has done just because the connection dropped. In practice that means three things: the main screens show the last data the phone already has; anything the user creates or records is saved on the device first and sent later; and actions that truly need the server – a payment, a live booking – say so clearly instead of failing silently. How far you go beyond that depends on where and how your users work. Below is a way to decide feature by feature, what it means for the budget, and what to test.
Why "no connection" is a normal state, not an exception
Android's developer guide to offline-first apps lists what users run into every day: limited bandwidth, short interruptions "such as when in an elevator or a tunnel", and devices that only go online occasionally, such as Wi-Fi-only tablets. It defines an offline-first app as one that can perform all, or a critical subset, of its core functionality without internet access. According to the same guide, such an app should:
- remain usable without a reliable network connection;
- show local data immediately, instead of waiting for the first network call to complete or fail;
- fetch data in a way that respects battery and data use – for example, only when charging or on Wi-Fi.
Not every app needs to be fully offline-first, but every screen needs a deliberate answer to "what happens here without a connection?" – otherwise the answer is an endless spinner.
Sort every feature into one of four groups
| Group | Without a connection | Typical examples |
|---|---|---|
| Works fully on the device | Everything works; data is sent later | Recording a trip or a measurement, filling in a form or checklist, taking photos for a report, writing a draft |
| Reads saved data | Shows the last known version, with a "last updated" note | Catalogue, price list, order history, schedules, saved articles |
| Queued | The user acts now; the app sends it when back online | Sending a message, leaving a rating, non-urgent profile changes |
| Needs the server now | Clearly disabled or explained | Payments, live availability, first login, anything where an outdated answer does harm |
Android's guide uses a bank transfer as its example of a write that must happen online in near real time; for such actions it suggests disabling them offline and telling the user why. The goal is not to make everything work offline – it is to make every feature behave predictably.
Example: when recording is the core task
Take an app that measures trips, 0–100 km/h acceleration, braking and laps on a track with the phone's GPS and sensors, such as roadmeter.app. Race tracks outside towns, mountain roads and tunnels are exactly the places where mobile coverage tends to be weak. For any app of this kind, the design rule is simple: the measurement must not depend on the connection. If saving a run waited for the server, a lost signal would mean a lost result – and a lap can't be repeated on demand. Features that genuinely need the server, such as comparing results with other drivers in a ranking, can wait until the phone is back online.
Three ways to handle what the user creates
Android's guide describes three strategies for writing data, each with a different cost:
- Online-only. The action goes straight to the server; if that fails, the user is told. Simple, and the right choice for payments and anything time-critical.
- Queued. The action goes into a queue and is sent when the connection returns, with growing pauses between retries. The guide recommends this when the data isn't essential, the action isn't time-sensitive and the user doesn't need to know if it fails – its examples are analytics events and logs.
- Saved locally first. The data is written to the phone first and sent at the earliest opportunity. The guide calls this "the correct choice when the data is critical to the app" – such as tasks added offline in a to-do app – but warns that it is nontrivial, because conflicts can arise when the app comes back online.
The guide also makes a point that matters for the budget: an app doesn't have to be able to write data offline to count as offline-first. Reading is the minimum.
Synchronisation and conflicts: decide the business rules early
When the phone reconnects, its data has to be reconciled with the server. If two people – or one person on two devices – changed the same record while offline, one change has to win. Android's guide notes that a common approach in mobile apps is "last write wins": each change carries a timestamp and the server keeps the newest. That's fine for a personal note. It's not fine for stock levels, bookings or anything where two valid changes must both count. These are business decisions, not technical ones:
- Which data can be changed offline at all?
- If two changes collide, which one wins – or should both be kept and someone notified?
- How old can saved data be before the app warns the user? Yesterday's price list may be fine; last week's stock levels are not.
- What happens to unsent data if the user logs out or uninstalls the app?
The server side matters as much as the app: the API needs a way to send only what has changed and to accept delayed changes safely. We wrote about that in one API for a website and a mobile app.
Tell users what is happening – in plain words
Most frustration with offline behaviour comes from not knowing what the app is doing. Google's offline UX guidelines and its Material Design work on offline states recommend:
- Inform users of a change in state as soon as possible – and tell them what they can still do.
- Don't rely on grey alone. Grey usually means "disabled", so greying out the app to show it's offline confuses people. Combine colour with text and icons – for example, a "cloud off" icon with a label such as "no internet".
- Use plain language. Avoid technical terms and describe what is actually happening: "Your report is saved and will be sent when you're back online."
- Show what's available offline, and give saved content a place that's easy to find – not hidden under "More" or "Settings".
- Ask before downloading large content and show its size, because mobile data costs money; make deleting saved content easy too.
- Tell users when the connection is back and queued actions have been completed.
Data on the phone has to be protected
Working offline means keeping data on the device – sometimes customer names, addresses or photos. Insecure data storage is one of the risks in the OWASP Mobile Top 10 2024. Keep only what the offline work needs, protect it, remove it on logout, and decide how long it stays on the phone. This is part of the design, not something to add at the end.
What offline support costs
Offline work adds a local database, synchronisation logic, conflict rules, extra screens and states, and a lot of testing. Full offline editing with synchronisation is one of the features that increase the effort most – see which features drive the budget of a mobile app. That's why the honest answer is often a smaller one:
- for an app people use at home or in the office, saved read-only data and a clear message may be enough;
- for an app whose core task happens where coverage is poor, saving locally first is not optional;
- in between, queue the few actions that matter and leave the rest online-only.
If you are planning a first version, our article on what belongs in the first release lists offline editing among the things that can wait – unless working without coverage is the core task.
How to test it
- Switch on airplane mode at every step of the main task, not only at the start.
- Cut the connection in the middle of sending data, then restore it.
- Test on a slow, unstable connection – often the harder case.
- Close the app, or restart the phone, while data is waiting to be sent.
- Change the same record on two devices while offline and check which version survives.
- Leave the app offline for a few days and check what it says about outdated data.
If your users work where the connection can't be trusted, start by putting each screen of your app into one of the four groups above. We can help turn that list into a design, a synchronisation plan and a supporting API, as part of our mobile app development service. Get in touch and tell us where and how your users work.