A technician is leaving a job when the app shows a green check. They close the phone, load up and drive away. Back at the office, the person reviewing the job has no photo. Both people did what the interface told them to do. The check was tied to selecting the picture, not saving it anywhere the office could see.
That is a small bug with an expensive shape. The next step might be a customer call, another visit, or a disagreement about whether a step was completed. It is also a clean design problem: stop making one check stand for four different events. A field photo can be saved on the device, waiting to send, accepted by the server, and reviewed by a human. Each is useful information. None is a substitute for the next.
Drafted with AI assistance for Apiary. The job, identifiers and examples are fictional. They are design and test fixtures, not claims about a deployed product.
Start small enough to make a real promise
A picture pipeline can grow into a library, a report generator, a search index or a quality dashboard. Don't promise those things to prove a transfer works. At the first checkpoint, the office wants to know whether it can see one picture for the correct task. The field tech wants to know whether it is safe to leave the capture screen. Those are different operational questions from whether a query can find every picture with a particular tag later.
Put an explicit starting condition on the first release. The job must already exist and be available locally before the phone loses connectivity. Supporting a just-created offline job introduces another dependency: the app must reconcile the local job identity with the office's accepted record before the media can be attached. If that feature isn't present, say so near capture rather than creating anonymous uploads the office must sort by timestamp afterward.
In a fictional route, one technician visits Cedar Display and another visits Pine Display. Both take a picture of a nearly identical packaging sign. One device has cached Cedar's job; the other has never loaded Pine while connected. A supported workflow lets the first technician save a picture scoped to the cached job. The second needs a supported fallback because selecting a generic account does not establish the receiving job. A blank destination may be valid for a named intake workflow, but it must not be called received by Pine's reviewer.
This is where several product commitments become distinct. Does “views offline” mean seeing a prior thumbnail, opening the full photo, or starting capture when the document itself wasn't previously loaded? Does “works when you close it” mean the local item survives or that the transfer continues? A preview and a working background job are different features. Proof of one isn't proof of the other. Write the supported claim in the status language the user will actually see.
Collect a baseline with synthetic files. On two common device types, write down whether the route opens from cold start under the offline contract, whether durable capture is possible, and whether its retry returns a receipt. If results differ by installed and browser-tab modes, don't merge them into a single pass. The aim is to find a supportable envelope, not convince the office that every field device can be treated like a laptop.
Start by making the failure happen
Set up a test job that does not contain a customer name, address, or real photo. Use a plain sheet with the fixture ID on it. Sign in on the phone and load the job while online. Take the phone offline, add the photo and close the browser or app. Reopen before reconnecting. If the image is not visible to the app, the workflow has already failed the first test. A promise about retries will not help if there is nothing left to retry.
Now reconnect. Do not immediately accept a green check as evidence of anything. Open the same job on a second device with a reviewer account. Does the photo open there? Is it attached to the expected job? Can the reviewer tell that it has not been reviewed yet? Finally run the same test with a second photo that looks similar, such as the same sheet turned 90 degrees. Ensure neither photo silently overwrites the other.
The first test separates local durability from network progress. The second separates remote persistence from visual optimism. The third separates media identity from content similarity. Those are the three decisions the design needs to get right before anyone adds a dashboard.
Give every state an owner
The phone owns the claim that it saved a photo on this device. The network transfer can report bytes sent without saying what happened at the other end. The server owns acceptance: a stable record tied to the job and an image the authorized review view can retrieve. The reviewer owns the decision about what the photograph demonstrates. The app may surface all these states, but it cannot invent a state on behalf of another participant.
A simple interface can show that in a single line of text:
| State | What the user can rely on | Useful action |
|---|---|---|
| Saving | The app is attempting a local write | Wait in the capture view |
| Saved here · waiting to send | A local transaction completed; no server receipt exists yet | Keep working; leave the photo queued |
| Sending | A transfer is in progress | Keep the screen open if the device requires it |
| Needs attention | The last outcome requires something more than waiting | Sign in, reassign the photo, or retry as applicable |
| Received · not reviewed | The server confirmed its record | Open or send for review |
| Reviewed | A named review action exists in the job history | Open the outcome and its notes |
“Saved here” needs a clear limit. The user might clear site data, change browser profiles, lose a device or switch to a different origin. None of those actions shares or transfers local data. The app can explain that in an info line or when a person tries to sign out with queued work. There is no need to put a paragraph of legal language beneath every thumbnail. A concise count at the job level, such as “2 saved on this phone, 1 received,” often tells the crew everything they need.
Avoid mixing two kinds of progress. A network bar reaching 100% tells you a transfer sent its bytes, not that the office can open them. A reviewer can reject a previously accepted photo without pretending it was never uploaded. If a technician replaces it, append a replacement record with a reference to the old one instead of simply changing the meaning of an earlier receipt.
Make the local queue useful across a shift
The most helpful queue shows why each item is waiting and which photos might need human action. A single spinner generates ambiguity. Consider a job with three captures. One completed the local transaction while out of coverage. One is still trying to save. One has a known format rejection. Their thumbnails may look identical. The board should not tell the worker to wait on an item that will never send or to retake something that merely needs a connection.
A first usable design can group by current job and state. Show “saved on this device” with a count and a reachable detail view. Keep separate counts for transfers whose outcomes are unknown, records received, and items that need attention. If totals are reported across jobs, preserve the per-job scope when someone taps a count. Otherwise they might see two pending and assume both belong to the site they are leaving.
Identify what a technician can safely do when a save hasn't happened. They can wait for the current operation, leave the capture screen after a confirmed local save, or use a distinct company-approved way to keep the source image. If the platform stops giving the app access to the selected file after closing, don't instruct the user that they can safely leave and return. UI text should distinguish when the browser's picker returned a file from when the app completed its durable write.
Metadata is subject to the same durability issues as image data. A photo may reopen while notes written immediately afterward don't. If the notes determine job identity or purpose, define whether the app saves those fields in the same logical operation or stores successive revisions. If an important edit is not yet committed, show that state clearly. Saying “everything is saved” because the image is present invites field staff to leave halfway through an evidence attachment.
Queue ownership has to remain intelligible on a shared tablet. If a day shift account captured a picture and the evening shift takes over, the tablet might still have a pending count. The right behavior is not automatically moving the captures onto whichever account is current. Apply the organization's device policy: protect the prior account's data, help that user resume authorized work, and provide a documented path if the session can't be restored. In a deployment that forbids persistence across users, address unsent work before changing sessions. Don't claim to recover a blob if the device no longer possesses it.
Save the thing, not its preview
On the web, a preview URL created for a selected file helps render the thumbnail. It is not the original bytes in durable app storage. A useful local queue record has a stable capture ID, the job reference, the blob, the media type, byte count, capture or import time qualifier, and enough state to restart the transfer. A user note can live in the same record if its lifetime matches the photo. Do not store credentials in that queue.
IndexedDB transactions let a browser app commit the queue metadata and blob together, or abort both. Tie the saved indicator to transaction completion rather than success on an individual write request; that request can succeed before a later operation aborts the transaction. IndexedDB also defines a durability hint. Treat it as a hint about how the browser commits, not protection from storage clearing, origin changes or device loss. If your app requests persistent storage, read the outcome rather than assuming it was granted. The Storage Standard gives browsers control over that decision.
There is a related failure that only appears late in a day: a phone has enough memory to display the preview, but the attempted durable write fails. Show a visible error and keep the capture screen open if the selected media is still available. Do not increment a “saved” count. Do not promise a write to the camera roll unless the platform actually performed it. Give the technician a clear way to try again or preserve the image according to the device's supported options.
If you compress large images, define what is preserved. A small preview can show a door or workbench while hiding a mark that mattered to the reviewer. Consider standardizing a capture format and keeping a larger evidence derivative than the thumbnail. Record when rotation or downscaling occurred if that matters for interpretation. A photo illustrates visible conditions. It is not proof of everything outside the frame, the date a repair was done, or the condition of hidden parts.
Know which file the office needs to see
A camera can generate a large portrait whose preview is turned correctly while the stored image carries an orientation flag. The reviewer may receive a smaller rendition produced later. Decide what the acceptance promise covers. If the office only needs a legible picture of a tag, define a target that preserves legibility. If an approved workflow requires original bytes, acceptance must not be issued for a lossy derivative alone. Preserve any derivative identity and its relationship to the accepted capture rather than changing it into a new job event.
Use a test pattern instead of a picture from a client visit: the fixture ID in each corner, an arrow at the top, and short labels printed at two sizes. Capture in landscape and portrait, rotate deliberately if the interface permits it, and compare the phone and office displays. A ghost status can occur even with correctly preserved bytes if the viewer crops the only useful part. That is a rendering problem after a good transfer, not proof that the photo failed to upload. Record separate results for receiving, retrieving, and interpreting the view.
An image library wants duplicates reconciled according to its own policy. A capture workflow wants separate events represented accurately. Suppose a technician deliberately attaches the same setup image to two fictional callbacks because it provides relevant context for each. A content digest may match, and storage may reuse bytes. Each attachment still needs its own intended job association and receipt. If storage cleanup drops the shared file when one link is removed, the other office view can break even though its receipt remains. Verification should follow associations, not just inventory stored objects.
If a different file reaches the same capture ID, don't call the conflict “already uploaded.” Put it where a person can reconcile whether the wrong selection was retried or a replacement was intended. A replacement can preserve the previous receipt while adding a new capture and an explanatory link. The reviewer needs to know which item is current without being misled about which was received earlier.
A media policy should also address optional enhancements. If a tool can make a thumbnail sharper or brighter, that suggestion is not the evidence being accepted unless the workflow specifically chooses it as such and records the source. Do not apply automatic image substitutions at the point of an uncertain retry. Keep the retry content stable and think of an alternate representation as a separately identified artifact.
Design the retry before the happy path
Imagine an upload that succeeds at the server just as the phone loses its connection. The office can see it; the technician saw a timeout. After reconnecting the technician taps retry. Without a stable capture ID, the system makes a second copy. The reviewer now has to judge whether the two items describe the same activity, while the technician thinks the first upload never existed.
Generate the capture ID once and save it with the blob. Reuse it when the app retries. Scope it to the job and account on the server. In a design where the server coordinates a blob store and a record database, publish the acceptance receipt only after both sides are usable. Those operations are not automatically atomic, so define an intermediate state and a reconciliation path when only one succeeds. A private, unreferenced object may be cleaned up after an agreed grace period; it must not appear as a reviewed item or be mistaken for a missing upload that should be duplicated.
For example:
captureId: cap-fixture-014
jobId: test-job-42
receivedAt: 2026-08-12T20:06:21Z
mediaBytes: 242018
status: received
reviewStatus: pending
The app can look up this receipt by the original capture ID before re-sending a large image. If an earlier record is for the same capture, return it rather than inserting a second item. If the same identifier arrives with a different payload, treat it as a collision or integrity problem. Do not replace the photo behind an existing receipt. Comparing a size alone is not sufficient for identity; a content digest can help verify a payload, while the capture ID continues to identify the intended event. Deduplicating every photo solely by content is also wrong: the same picture may intentionally be attached to separate fixture jobs for different reasons.
In this example the client sends a job ID, not a destination bucket chosen by the viewer. The server checks the authenticated account and the job assignment on each operation. A request that is rejected because eligibility changed is different from a network timeout. Make it an actionable state, not a loop that quietly burns battery. When authorization has expired on a disconnected device, keep the local queue intact and ask for reauthentication at a useful time; do not keep sending blind retries or silently hand the queue to a different signed-in account.
Work through storage success and record failure
The queue's hardest scenario often has good connectivity. Consider a synthetic upload where storage returns success for a completed object, but the application fails while recording job association. An object exists in a protected intermediate location; the office sees nothing. If the app reports received, it has overstated what exists. If retry creates a new capture record every time, it can accumulate orphaned data without resolving the job. Hold the durable status at an honest intermediate or unknown state and follow a reconciliation path.
Design that path deliberately. A test server can note the original intent, populate storage, attempt the record, and on next lookup reconcile whether an earlier attempt left an object matching the request. It should reference expected identity and authorized association, not just search arbitrary objects by timestamp. If requirements for accepted data aren't met, it may abandon or retry the incomplete operation under a documented policy. The client should not choose a different destination just because it still has bytes and a previously useful route.
Compare the opposite failure: the job has a record, but it references an object the office cannot open. That can happen through a bad attachment, failed transformation, or inconsistent read-side authorization; don't announce an exact cause until tested. Verify opening from the authorized review context. If it fails, distinguish stored-but-not-usable from forbidden-for-this-user and stale-or-missing media. Staff can then choose whether they need a retry, a permission diagnosis, or the appropriate account.
A receipt can define its own limit: “The job has an accepted photo as of this event; opening is currently unavailable.” That lets the app retain truthful history after a permission change without promising indefinite access. The office may need another authorized reviewer, not a second copy reattached by a different route. Moving a protected file out of its authorized system to bypass a viewer problem changes exposure and is not a substitute for fixing the read path.
A connected phone is not necessarily a reachable server
Browser connectivity is a hint. An office Wi-Fi access point can be visible while its internet connection is down. A portal can intercept traffic. A request can reach the app server while a storage service is still returning an error. The HTML Standard defines the signal as connectivity information available to the user agent, not proof that your endpoint is reachable. Use it to wake the queue or explain likely offline status. Use the app's own authenticated response to update the durable upload state.
Distinguish at least four outcomes. The network timed out and the server outcome is unknown; check the receipt. The service is temporarily unavailable; wait and retry with a bounded, delayed schedule. The request requires a new sign-in or changed permissions; ask for a person. The server confirms acceptance; save the receipt and stop retrying. If the photo itself is unsupported or above an enforced cap, give an explicit size or format error that a person can act on.
The point of this vocabulary is to help a tired crew make a correct choice, not to build the most elaborate status engine possible. A single “Retry now” action can be useful after connectivity returns. A screen that says “10 attempts remaining” with no diagnostic or next step is rarely useful. Keep automatic attempts finite and visible, and ensure two tabs cannot continuously run the same queue against each other. Server-side idempotency still matters even if the client coordinates attempts well.
Put uncertainty into the field handoff
Imagine a worker reaching reception at 14:50. The app begins to transfer two photos. It finishes one and loses its second response as the worker navigates. The worker calls dispatch to ask if both arrived. A useful answer shows the first receipt, treats the second outcome as unknown, and offers a receipt lookup keyed to the same saved intent. It should not require describing the pictures by color over the phone or accepting a second upload based on a vague preview.
Office text should reflect what it can actually know. “No received photo for the required step” is different from “the technician didn't take a photo.” The office may have no visibility into private local queues; that doesn't mean work was skipped. If a person needs to contact the technician, help them ask a precise question: “Does your device say saved here or needs attention for the entry labeled Before packing?” This starts with evidence, not blame.
Provide a low-bandwidth view where feasible. Dispatch may not need to download every image to answer whether a receipt exists; the reviewer needs an approved preview or open action to judge it. A thumbnail fetched from a different endpoint can complicate what available means. Check that the UI distinguishes an accepted media object from a failing thumbnail fetch. Don't infer missed submission from a placeholder.
Operators need actions like reauthenticate, retry transfer, open receipt, view replacement, or ask a reviewer. Avoid placing a generic fix action near a destructive deletion. An intentional local delete of unsent evidence can be hard to reverse; follow established authorization and retention rules and make consequences clear. Dismissing a warning should not quietly delete the only remaining capture.
Protect the evidence without making it hard to use
A field photo can reveal more than the job. It may show a face, a home address, another worker's paperwork, a vehicle plate or a device screen. Ask people to frame only what they need. Decide deliberately whether location metadata is necessary for the job. Don't surface a publicly shareable image URL simply to make a review thumbnail easier to load. Let authorized reviewers access the image, and let the same permission rules apply if somebody copies a job link and sends it to another account.
Keep a clear distinction between capture time and receipt time. A device clock can be wrong. A photo can be imported hours after it was taken. Record which clock supplied each value and avoid phrasing that makes a receipt timestamp sound like a trusted on-site timestamp. If a reviewer needs location or chain-of-custody evidence, design and validate that separately. An upload succeeded is an operational fact, not a claim that the server authenticated when or where the underlying event occurred.
Avoid making cleanup punitive. After acceptance an app may remove local image bytes according to its retention policy, but should preserve enough receipt metadata to explain where the item went. Present lost local bytes without a server receipt as a potentially lost photo, not an item successfully “archived.” If sign-out while uploads are pending requires a policy decision, define that behavior for shared tablets as well as personal phones. Test with two synthetic users in succession.
Write the test so it can fail
A useful demo is not “turn off Wi-Fi and the UI changes.” It has specific checks that fail when photos are lost, duplicated or misattributed. Playwright's browser-context offline mode is one tool for simulated connectivity. You can toggle it around a capture, reload and check the queue without hitting production. To model acceptance followed by loss of response, have the fixture record one acceptance and then deliberately fail the first client response. Test the app's behavior both with an acceptance receipt already present and with a server that never accepted anything. Keep these tests independent.
A small acceptance matrix is enough to start:
| Failure injected | Required observable evidence |
|---|---|
| Offline capture, then restart | Same fixture capture ID and visible image; no server acceptance shown |
| Local write throws or transaction aborts | No “saved here” state, actionable warning |
| Server persists, response lost | Retrying or looking up receipt shows one acceptance; one photo on second device |
| Sign-in expires on reconnect | Queue remains intact and stops retrying until the right account is restored |
| Account changes in a shared browser | Old user's queued image is not attached to the new user's jobs |
| Reviewer rejects an accepted photo | Original receipt remains; review outcome and replacement are distinguishable |
| App opens while random Wi-Fi is reachable but server is down | No premature acceptance or endless spinner |
Then repeat the first and third scenarios on the actual phones the field team supports. Simulated offline mode does not exercise camera permissions, OS process eviction, background execution, device sleep, storage limits or system-specific browsing behavior. A successful desktop run is evidence about that simulated browser path only. Record browser and operating-system versions, whether the app was installed or in a tab, fixture IDs, and what the second device observed. No need to paste customer images into the QA thread.
There is a cheap manual server-side control, too. Make a test view that shows the count of distinct accepted captures by job and opens each one as an authorized reviewer. Without that independent check, the same buggy code that produces the badge could also produce the test's success signal. A second view gives the team something tangible to argue with instead of comparing screenshots of the same state.
Use a failure ledger another person can reproduce
A test worksheet can include fixture name, account role, device mode, time local write completed, transfer attempt, server disposition, second-device retrieval result and review status. Record direct observations. “Got a 200 and displayed a receipt, but review context couldn't open it” is a valid divergent outcome. You don't have to choose which half to trust until you test the discrepancy under a controlled setup.
Try an awkward interruption. Begin with a stored local capture. Simulate a slow transfer, then switch the phone from Wi-Fi to cellular in a supported test setup. Record the result rather than assuming what the operating system did with the process. In a separate test, relaunch and check a receipt for an upload intentionally made to succeed on the server without returning a response. Split control from observation so a bad screen isn't the only evidence of a good run.
Another fixture tests lost device scope without using a real loss. Create a saved, unsent item in a disposable profile, open the same test job from a new authorized profile, and compare what each can see. Then perform a controlled reset of the disposable fixture under normal test procedure. The expected outcome isn't that the new profile magically knows the old locally saved bytes. It is that the product doesn't claim cross-device persistence it hasn't implemented. If there is a secure backup path, test that separately using approved synthetic material.
Write one failure worth blocking release for, such as a received badge with no attached, accessible asset in the required scope, a retry that duplicates an intended attachment, or account switching that reveals another user's image. A minor wording issue may not be the same priority as loss of private evidence. State supported contexts and checks not yet run. An honest receipt for QA has the same shape as the receipt you're building for users.
A handoff you can use tomorrow
For a small team, the first release only needs to support a narrow contract: capture before connectivity disappears, survive reload, show how many items are waiting, retry without a duplicate, and let the office open each accepted item. Start with one photo type and the phones actually used. Put the state names in the acceptance criteria and add the receipt ID to the test log. Keep a short explanation for technicians: “Saved here means it's on this phone. Received means the office can open it. Reviewed means someone made a decision.”
If the work involves regulated inspections, contractual evidence, or sensitive client spaces, that baseline is not a substitute for a formal review of retention, access and authenticity. Build the operational contract first so there is something definite to evaluate. The proof that the app is ready is not a faster animation or a greener check. It's a technician turning off a connection, shutting the app, opening it again, and seeing the same photo on the office screen exactly once when the network comes back.
Measure a path before measuring a product
Pick a start and finish you can actually observe. Capture-to-receipt measures time until the office can verify acceptance. Receipt-to-review measures time until a qualified reviewer records a decision. Downloads, thumbnails and cache hits may explain slowness but don't substitute for those milestones. A project can improve transfer time while leaving review backlog unchanged. State which clock supplied each milestone and flag records where timings aren't comparable.
In an invented run of six eligible captures, five local transactions completed. Four of those produced server receipts within the defined window; one stayed pending. Three authorized review actions were observed, with one remaining unreviewed. This is not a three-of-six upload success rate. Different denominators answer different questions. Attach pending counts and explain the test window. If a case arrived after closeout, record the later receipt without pretending it was visible in the earlier report.
Keep the capture event distinct from a supervisor's assessment. A rejection for framing means the file made it to the office and someone couldn't use it as intended. Opening a thumbnail in the queue may count as retrieval evidence, but don't conflate it with formal review. A policy can require a deliberate action that identifies the completed assessment and scope. That distinction makes rework measurable without penalizing the transfer path for a poor photo.
For a narrow rollout, start with one fresh capture path, one supported restoration path and one office role. Prove those first. Don't expand to indexing, classification, or image search because a second-device open worked. The value of the first release is simpler: a person knows when they can trust what the phone says, and the office has a specific receipt when a photo makes it across.
Set expectations before a field route starts
An offline queue's behavior is often tested when someone still has a strong connection and plenty of free space. A first practice run should instead include a morning device check and an end-of-route check. Open the intended work assignment while connected, record the locally available job reference, and use a synthetic capture to make sure the queue comes back after close and reopen. If the application has a supported storage-warning mechanism, test it in a disposable profile so staff can recognize the real indicator without deliberately endangering an active job.
Give the office a simple closeout view. Separate “every required capture has a receipt” from “some requirement is unresolved,” and make the exact missing record visible. A job can have one accepted picture and still lack the required second picture. Conversely, delayed review shouldn't obligate someone to resend material that is already available. Decide who is expected to act and whether the office closeout can proceed while a review is pending. Those policy decisions should not disappear behind a count.
When a new release changes the upload behavior, record the first version where the contract applies. An old installed client may still display the old badge. A field trial that verified one browser build should not announce a fix for old clients without a supported update or a clear fallback instruction. Ask support which status they will use to recognize old versus current behavior. The goal is to avoid making two people interpret the same green shape as two incompatible facts.