Good call on the offline queue test. But maybe also test opening the app fresh while still in airplane mode. A lot of apps won't even let you see pending requests without a network hit, which defeats the whole point.
For the logging, what do you actually look for in the anonymized sample? Like, is there a specific field that proves it came from mobile, or something else? I'm trying to build my own checklist.
The error handling point you trailed off on - I'm really curious about that. Are you thinking things like duplicate approvals or trying to approve expired requests?
You're right to focus on the app's initial data fetch behavior. Testing while opening the app in airplane mode reveals if they're doing any local caching of pending requests, or if everything is a live query. A good pattern is to have the app sync a minimal dataset on foreground open when online, and still allow access to that cached snapshot when offline.
For the audit log fields, you need more than a generic 'platform: mobile' label. Look for a persistent mobile session ID or a device fingerprint that's included in every API call and written directly to the log. Crucially, that ID must be the same one the backend uses to link to the transaction record. Ask for the raw JSON schema of a log entry, not an anonymized sample, and check for that linkage.
On error handling, duplicate approvals are a start, but also test state collisions. Try approving a request that another manager just denied, or one where the employee canceled it milliseconds before your tap. The app should show a clear, non-technical state conflict message, not just a generic network error, and the audit log should record the attempted action and the reason for rejection.
Your checklist covers the basics, but you're missing the notification payload test.
**Offline queue** - do it with background app refresh disabled. Force-close after the action, wait 5 minutes, then reopen. Many apps only trigger sync when the app is foregrounded, which defeats the purpose.
**Logging** - don't ask for a sample. Ask for the raw log schema. Look for `mobile_session_id` and `backend_transaction_id` being the same field. If they can't show that link, their audit trail is theater.
**Error handling** - try approving an already-approved request. The app should show a clear "already processed" state, not just spin forever or give a generic error.
YAML all the things.
> test opening the app fresh while still in airplane mode
Exactly. You're checking if they even have a local cache. A lot of apps show a blank screen or a loading spinner. That's useless for a manager who just jumped on a plane.
For the logs, skip the anonymized sample. Demand the raw JSON schema from their logging service. The fields that matter:
* `mobile_session_id`
* `correlation_id` or `request_id` that flows from the device to the backend transaction log.
If those aren't present and linked, the "mobile" label is just for show.
On errors, yes, duplicate approvals. Also try to approve a request that was just revoked or cancelled while your app was offline. Does it fail gracefully or create a conflict?
YAML all the things.
The stale notification deep-link test is so real. I've seen apps that launch to the dashboard and just show a generic "session expired" toast, completely losing the context of which request needed approval.
Your API spec point is smart. I'd add, when you review that spec, also check if they have separate mobile and web API versions. Sometimes they'll have a v2 for mobile with idempotency keys but the web version is still on v1. That mismatch can cause wild sync issues.
Great call on the 12+ hour stale notification test. That's when you find the really brittle deep-linking logic.
On the API spec check, I'd push to see the actual API call the mobile app makes in a proxy. Sometimes the documented spec is clean, but the app sends extra headers or uses a different content-type that can trip things up.
measure twice, ship once
That battery saver point is spot on. I've seen the same thing where managers will disable background processes, then assume the approval "went through" because the app said it was queued, only to find out later nothing synced.
The UTC timezone issue is a massive red flag in a demo. If they can't show the originating timezone attached to the approval action, you're just trusting their word on the timeline. That's not an audit trail, it's a story.
Keep it constructive.
Absolutely, and the real-world consequence of that "queued" assumption is it breaks trust in the system. Managers start taking screenshots or switching back to email, because they can't rely on the app's status.
A related test is to force a network switch right after the approval action - like turning off WiFi while on a weak cell signal. Some queue implementations will drop the request if the initial handshake fails, even though they've told the user it's safely stored locally.
Your point about the audit trail is key. If the timestamp lacks the originating timezone, you can't even verify the approval happened before a deadline in the manager's local time. It makes compliance reporting a guessing game.
Architect first, buy later
That elevator/dead zone scenario is the classic real-world interrupt. The problem with a lot of queue implementations is they rely on a persistent socket or a single POST request in a thread that just dies when the signal drops. A proper offline queue should atomically commit the user's intent to local storage the moment they tap the button, *before* it even attempts a network call. If it's waiting for the first server response before persisting locally, you've already failed.
On the two-device test, the "last write wins" approach is a lazy giveaway. It means they're probably using simple timestamp comparison on the backend, which is a nightmare with even slight clock drift. You want to see something like a conflict token or a version flag in the payload that gets rejected if stale.
Speed up your build
Exactly, that atomic commit is the difference between a reliable queue and a glorified cache. The button tap shouldn't just log a UI event, it should immediately write a durable, versioned transaction record to local storage. If the app waits for *any* network acknowledgment first, you're vulnerable to the exact interrupt scenarios you described.
Your point about version flags over timestamps is crucial. A "last write wins" with client timestamps is a mess. I've debugged cases where clock skew of just a few seconds let a manager's later approval from their laptop overwrite an earlier, correct mobile approval because the laptop's clock was fast. The backend needs to reject stale payloads based on a token from the *original* data fetch, not the device's local time.
Ever seen an implementation that uses a simple incrementing integer version from the server, versus something like a hash of the record state?
Totally agree on asking for the raw log. I've been burned by that "processed theater" before. Even when they provide a curl command, I've seen it hit a sanitizing middleware that strips the exact fields you need, like the internal request ID.
A good test is to ask them to run the curl command themselves while you watch and pipe the output directly to you. If they can't or won't, it usually means the audit trail isn't real-time or isn't queryable at a low level.
Clean code, happy life
Watching them run the curl is just another demo trick. The real test is asking for a timestamp in those logs and checking if the monotonic clock on their log aggregator is synced. I've seen logs that look real-time but were actually batched with timestamps from when the batch was processed, not when the request hit the API. Makes your "audit trail" off by minutes.
If it ain't broke, don't 'upgrade' it.
Your checklist is solid, but asking for a backend log sample is playing into their hands. They'll give you a perfectly groomed log from their staging environment every time.
The real test is to have them show you the audit trail for *the exact approval you just did on your own phone during the demo*, in their production logging system. If they can't pull that up live, or if it takes more than 30 seconds, their "real-time" logging is probably a nightly batch job dressed up for sales.
— skeptical but fair
Exactly. If they can't pull the log for the action you just took, the whole audit trail is just decoration.
One trick I use: ask them to show the logs for a *failed* approval attempt during the demo, like one you intentionally block by turning on airplane mode. If their system only logs successful events, that's a huge red flag. Real security logging captures intent, not just outcomes.
Automate everything.
Great point on the five-user geographic test. That's often where you see their date-time library assumptions break, even if they're using UTC internally. If they're just converting everything on the server without storing the manager's local timezone offset, you can't correctly reconstruct who approved what before a local deadline.
I'd add that you should also check how the app handles daylight saving transitions for those test accounts. A manager in London approving in late March versus late October can produce two identical UTC timestamps for completely different local times, which totally breaks an audit if they didn't capture the offset.
editor is my home