List each verification type (e.g., National ID, Passport, Driver’s Licence, Bank Statement, Health Card) and the exact attachments required. For each type, specify:

• Which sides are required (front, back, both).
• Whether a selfie or a live face photo is required.
• Whether a recent document is required (issued/expiry dates).
• Any additional documents (address proof, bank statement) and date windows (e.g., last 3 months). Make a short human-readable checklist for each verification type to show to users.

For each document type decide allowed formats:

• Images: JPEG, PNG (common).
• Documents: PDF (single- or multi-page), sometimes TIFF (if provider accepts). Record any provider-specific restrictions (some verification partners accept only JPEG/PNG, others accept PDF).

Define maximum file sizes and recommended minimum quality/resolution:

• Typical recommendation: image files <= 10 MB; PDFs <= 20 MB.
• For mobile photos encourage 1–5 MB images at 1500–3000 px on the long side for legibility. Document these limits in the UI and test with your verification provider’s requirements.

Add a concise requirements panel (checklist) at the upload step that shows:

• Required items in order (e.g., “1. ID front, 2. ID back, 3. Selfie”).
• Allowed formats and file-size limits.
• Example images of acceptable vs unacceptable photos. This reduces user mistakes and saves review time.

If a user can’t provide an item (e.g., no scanner, brittle card), show alternatives:

• Take a mobile photo with in-app camera.
• Upload a multi-page PDF if supported.
• Contact support or request manual review if the provider rejects the automated check. Document who in support to contact and what information to collect.

When users land on the upload step show:

• Which documents are required.
• Allowed formats and size limits.
• Live examples labeled “Acceptable” and “Not acceptable”.
• An estimate of how long verification usually takes after a successful upload.

Offer two paths:

• Take a photo with their device camera (preferred for mobile).
• Choose an existing file (desktop or mobile gallery). Make the camera option crop/guide for card edges and allow re-taking a photo before upload.

Immediately validate:

• File type (MIME / extension) matches allowed types.
• File size is within your limits.
• Required number of files are provided (e.g., front + back).
• For images: detect obvious issues like extreme rotation, very low resolution, or heavy compression (use a resolution check). If a check fails, show a clear, friendly error with one-sentence guidance (see examples below).

Display thumbnails or PDF previews with labels (e.g., “ID — front”). Allow:

• Rotate / crop adjustments for images.
• Replace or remove an uploaded file.
• A final “Confirm & Submit” button that remains disabled until validations pass.

Show progress indicators (percentage or spinner) and a cancel button. If upload is slow, show an ETA and allow the user to continue other steps while upload completes in the background, when possible.

After successful upload show a friendly confirmation page that lists what was uploaded and the next steps. If the verification is automated and instant, show the result; otherwise show “Pending verification” with an estimated timeframe and support contact info.

If a verification is rejected, allow users to re-upload the specific failed documents without repeating the whole subscription. Make it obvious which file failed and why.

Validate formats and show these messages:

• Acceptable: “JPEG, PNG, or PDF”
• If invalid: “That file type isn’t supported. Please upload a JPEG, PNG, or PDF.”

Enforce size limits and show:

• If too large: “This file is too large. Please upload files smaller than 10 MB. Tip: take a picture with lower resolution or save as PDF.”
• If borderline: show a compression tip and recommend using the camera in recommended mode.

Ensure all required pieces (front, back, selfie) are provided. If missing: “We need both the front and back of your ID to proceed. Please upload the back side.”

Detect and warn about common issues:

• Blurry/low-contrast photo: “Try taking the photo again in daylight or with more light.”
• Cropped edges: “Make sure the entire document is visible.”
• Rotated images: “Rotate the image so the text is horizontal.” Provide an inline “Retake” button for camera captures.

If a PDF is accepted and multiple pages are required, instruct users to:

• Put page 1 = front, page 2 = back, etc.
• Name pages logically (if the UI allows). If the PDF is a scanned image, recommend a 300 DPI scan.

Offer translations for upload instructions and ensure the flow is keyboard- and screen-reader-friendly. Caption each step (e.g., “Upload front of ID”) and provide alt text for example images.

Adopt a consistent naming scheme that links each file to the subscription and document purpose. Example pattern (human-readable): [subscription-id] / [document-type] / [timestamp]-[original-filename] This makes it easy for support and reviewers to find files. Keep names short and avoid special characters.

For each uploaded file, capture these metadata fields and make them visible in the reviewer/support UI:

• Subscription ID (or user ID)
• Document type (ID-front, ID-back, selfie, bank-statement)
• Upload timestamp
• Original filename and file size
• Upload status (pending, uploaded, failed, verified)
• If relevant: device type (mobile/desktop) and browser/app version (helps debugging) This metadata helps support triage without asking the user for the same file again.

When a user re-uploads a replacement document, keep previous versions for audit and support. Mark the latest as the active submission but keep a clear history entry indicating who uploaded it and when.

Decide retention windows (e.g., keep documents for X months after rejection/acceptance) in line with privacy rules and provider obligations. Provide a link in support copy explaining how long files are retained and how users can request deletion.

If automated verification fails and a human needs to step in, add clear reviewer flags and short notes explaining why the provider rejected or flagged the file (e.g., “Photo too dark”).

Prepare specific UX behaviors for:

• Validation errors (wrong format, too large, missing side)
• Upload failures (network timeout, interrupted upload)
• Provider rejections (document illegible, mismatch, expired) Each type should show distinct messages and actions the user can take.

For each error state, show a succinct message and two clear actions:

• Fix now (re-take or replace file)
• Get help (contact support / chat / FAQ) Example copy for provider rejection: “We couldn’t verify this document because the text was unreadable. Please re-upload a clearer photo of the front of your ID.”

If verification requires multiple attachments, let users replace only the failed document(s). Highlight the failed item with a short reason and keep the successful uploads intact.

If upload fails due to network issues, allow:

• Immediate retry button that reattempts the upload.
• Automatic retry attempts in the background with a friendly toast: “Upload failed. We’ll retry automatically — or you can try again now.” If the upload repeatedly fails, provide an option to upload via a different method (desktop if on mobile) and a path to contact support.

When notifying a user (or support) about a failed verification, include:

• Which document failed and why (legibility, missing side, expired).
• A link to re-upload just that document.
• Suggested capture tips (lighting, distance, full frame).
• If applicable, a request for alternative documents and an estimated turnaround time for manual review.

If the user cannot provide acceptable documents after repeated attempts, provide a documented escalation path: secondary verification options (video call, in-branch verification), and instructions for support to initiate them.