Back to all articlesLead capture

Make mobile enquiry forms usable without a perfect connection

Alactic Editorial10 min read

Prepared with AI assistance by Alactic Editorial. Examples identified as hypothetical are illustrative, not customer results.

A visitor finishes an enquiry on a phone, taps Send and sees a spinner. The connection drops. When the page returns, the form is blank. Did the business receive the enquiry, or should the visitor type everything again?

A usable mobile form must make that question answerable. Specify keyboard and focus behaviour, show errors beside the relevant answers, preserve work through recoverable interruptions, and distinguish confirmed receipt from an outcome that is still unknown. Then test those behaviours on representative phones, not just a narrow desktop browser window.

The acceptance checklist below turns those requirements into observable tests. It covers browser-based enquiry capture, not mobile staff workflows or the availability of features in an Android app.

1. Define what counts as a completed enquiry

Start with the receipt rule. A button tap, a completed animation and an outbound network request are not sufficient evidence that an enquiry has been recorded.

Ask the implementation team to define the event that permits a success message. A useful design is to show confirmed receipt only after the service responsible for recording the enquiry has acknowledged acceptance. If the form passes information to another system later, distinguish receipt from that later processing.

Specify these visitor-facing states before discussing visual design:

  • Editing: answers can be changed and the form has not been submitted.
  • Needs correction: submission cannot proceed until identified fields are corrected.
  • Sending: an attempt is in progress; avoid starting another attempt through repeated taps.
  • Received: the service has confirmed acceptance.
  • Not sent: the application has reliable evidence that the attempt did not reach acceptance.
  • Outcome unknown: a request may have been accepted, but the browser did not receive confirmation.

The last distinction matters most on an unreliable connection. A timeout does not, by itself, prove failure. Do not display an instruction to submit again as though nothing could have arrived. The interface needs a recovery path that checks the original attempt or retries it safely.

2. Make input controls fit the answer

Keep the initial enquiry focused on information needed to understand and route the request. Every additional required field creates another place where a visitor can become blocked. Defer information that a person can reasonably collect during follow-up.

For each remaining field, specify the label, input type, keyboard hint, autofill behaviour, validation rule and error message. Use persistent visible labels rather than relying on placeholder text that disappears as the visitor types.

  • Email: provide an email-appropriate keyboard, avoid unwanted capitalisation and allow paste.
  • Phone: provide a telephone-friendly keyboard while accepting the formats the business supports. Do not treat a phone number as a quantity or strip meaningful leading characters.
  • Name: avoid restrictive rules that reject ordinary punctuation or spacing without a genuine operational reason.
  • Enquiry: use a multiline control that remains usable as the answer grows. Show any necessary length restriction before it becomes an error.

Keyboard hints are conveniences, not validation. A visitor may paste text, use dictation or choose another keyboard. Validate accepted input independently, and explain corrections without deleting what was entered.

Native controls can reduce custom interaction work, but they still need device testing. A custom selector may look consistent while introducing difficult scrolling, hidden options or poor focus behaviour. Choose it only when its benefit justifies those additional tests.

3. Keep focus, errors and the keyboard in the same conversation

When the keyboard opens, the active field, its label and any relevant error must remain reachable. A fixed footer or consent banner must not cover the answer or trap the visitor above the next control.

Do not assume that a sticky Send button is always helpful. On a small display it can consume the space needed to read and edit a long message. Test whether it should move with the document or change behaviour while the keyboard is visible.

After a failed submission, provide a short error summary and a deliberate focus destination. One workable pattern is to focus the summary, with links that move to the affected fields. Another is to focus the first invalid field while ensuring the overall problem is communicated. Choose one predictable approach rather than letting focus jump unpredictably.

Each field error should say what needs to change. For example, a hypothetical email error could read, Enter an email address with a name and domain, such as name@example.com. Avoid using colour alone to identify errors, and keep the message visible when the visitor returns to that field.

Allow zoom and test enlarged text. If zoom makes a field or action inaccessible, repair the layout rather than removing the visitor's ability to enlarge it. Also check that the focus order follows the reading order and that status changes can be understood with a screen reader, without repeatedly interrupting typing.

4. Preserve answers deliberately, not indefinitely

Preservation has several levels. Keeping values after a validation error is different from restoring them after a page reload, a browser restart or a return visit. Write down which situations the form supports.

A practical baseline is to retain answers during validation, slow responses and recoverable network errors. Decide separately whether to support reload recovery and returning later. If a flow cannot preserve answers in a particular situation, make that limitation explicit in the design review instead of assuming the browser will handle it.

Persistent drafts introduce a trade-off: they can prevent lost work, but may expose enquiry details to the next person using a shared device. Choose where drafts are stored, which fields are included, how long they remain and how visitors can clear them. Avoid storing sensitive free text merely because it is technically convenient.

Restoration must also respect submission state. A draft associated with a confirmed enquiry should not reappear as an unsent request. A draft associated with an unknown outcome should retain that warning, not return as an ordinary blank submission opportunity.

If server-side drafts are used, access must be authorised for each draft. Possession of a draft identifier is not sufficient authorisation. This follows the object-level access principle described in OWASP's API security guidance; it is a design consideration, not an assessment of any particular product.

5. Design recovery around the original attempt

The browser cannot solve uncertain receipt through wording alone. The service handling submissions needs a defined way to recognise an attempt and avoid creating another enquiry when that same attempt is retried.

Ask the implementation team to document how it handles a stable attempt identifier, repeat requests, receipt lookup and the lifetime of duplicate protection. These are recommended design requirements, not assumptions about an existing platform.

  1. Before sending: preserve the submitted answer set and associate it with an attempt.
  2. While sending: show a textual status and prevent repeated taps from starting independent attempts. Do not clear answers.
  3. If confirmation is delayed: explain that receipt has not yet been confirmed. Do not convert a waiting threshold into a claim of failure.
  4. After interruption: check the original attempt where supported. Otherwise, present an honest unknown state and the available next step.
  5. On retry: reuse the original attempt identity when retrying that same submission. Define separately what happens if the visitor edits the answers.
  6. After confirmed receipt: show a stable confirmation and stop presenting the draft as unsent.

Hypothetical unknown-state copy might read: We could not confirm whether your enquiry was received. Your answers are still here. Check the submission status before sending again. Only offer that check if it actually works. If reliable checking or safe retry is unavailable, acknowledge the limitation and provide a genuine alternative contact route. Do not disguise an unsupported recovery path with a reassuring button.

6. Filled hypothetical mobile acceptance checklist

Fictional worked example: The following observations are invented to demonstrate a completed checklist. They are not hands-on test results, customer evidence or product claims. Every device condition, timing and retention choice below is hypothetical.

The fictional form contains name, email, optional phone and enquiry fields. Its proposed draft behaviour preserves answers in the current tab, supports reload recovery for a hypothetical thirty-minute period, and clears the draft after confirmed receipt or an explicit discard action.

Keyboard obstruction — fail

  • Setup: Small-screen iPhone, Safari, portrait orientation; enter a long enquiry with the keyboard open.
  • Acceptance: The current line, label and error remain reachable; no fixed element covers the input.
  • Hypothetical observation: The fixed Send bar covered the last lines of the enquiry. Scrolling did not reveal the cursor.
  • Required change: Remove the obstruction while the keyboard is open. Retest typing, scrolling and reaching Send without dismissing the keyboard.

Zoom and enlarged text — fail

  • Setup: Android phone, Chrome; enlarge page content and increase text size in a separate run.
  • Acceptance: Labels, errors and actions remain readable and operable without clipped content.
  • Hypothetical observation: Inputs remained usable, but the error summary was clipped by a fixed-height container.
  • Required change: Allow the summary to expand and wrap. Retest navigation from each error to its field.

Visible errors and focus — pass

  • Setup: Submit with an invalid email and an empty enquiry, then correct both.
  • Acceptance: Errors identify the fields, focus moves predictably, and valid answers remain intact.
  • Hypothetical observation: Focus moved to the summary; its links reached the relevant fields. Name and phone values were retained.
  • Follow-up: Repeat with a screen reader and an external keyboard before treating accessibility checks as complete.

Slow response — pass

  • Setup: Delay the acceptance response by a hypothetical twelve seconds; tap Send repeatedly.
  • Acceptance: A sending message remains visible, answers stay intact and repeated taps do not create independent attempts.
  • Hypothetical observation: The interface stayed in Sending. Test records showed a single accepted enquiry, followed by confirmation.
  • Follow-up: Test a longer delay that reaches the application's waiting threshold.

Interrupted submission — fail

  • Setup: Interrupt the connection after the test service accepts the enquiry but before the browser receives its acknowledgement.
  • Acceptance: The interface shows an unknown outcome; recovery resolves the original attempt without another enquiry.
  • Hypothetical observation: The page claimed the send had failed. Retry created a second test record.
  • Required change: Correct the state message and implement attempt-aware recovery. Treat this as a release blocker for this fictional form.

Returning to the form — mixed result

  • Setup: Enter answers, switch to another app, return, reload, then revisit after confirmed receipt.
  • Acceptance: Unsent answers return within the documented draft period; a received enquiry does not return as unsent.
  • Hypothetical observation: App switching and reload restored the draft. Browser Back after receipt restored an active Send button with old answers.
  • Required change: Reconcile restored page state with confirmed receipt. Offer a clearly separate new-enquiry action.

7. Run the checklist on devices your visitors actually use

Choose representative combinations using available visitor data, while including a small screen and different browser engines. If data is unavailable, record the initial coverage assumptions and revisit them after launch. A simulator is useful for iteration but does not replace checks involving real keyboards, app switching and browser restoration.

Test ordinary completion first, then isolate failures. Include a connection loss before sending, a delay during processing and an interruption after acceptance. Simply turning off connectivity once cannot establish that all three states work.

Use fictional contact details and enquiry text. For each run, record the device, operating system, browser version, text settings, connection condition, steps, visible result and corresponding test record outcome. Screenshots show layout; they do not establish whether an enquiry was stored twice.

Assign an owner and retest condition to each failure. For the fictional checklist above, the next measurable action is to rerun the four failed or mixed checks after fixes, then verify that each produces the specified visible state and expected record count. Keep the observations with the release decision so that a future redesign can be tested against the same behaviours.

Lead captureMobile formsUsabilityAcceptance testing

Put the next conversation to work.

Explore Alactic Communications for WhatsApp conversations, campaigns and AI-assisted workflows. Choose the product and plan that fit your team.

Explore Communications