Built from scratch2026

Reubro Field Pro

Work orders for calibration teams in the field

A field service app with two roles. Technicians record inspection and calibration readings on the phone. Supervisors assign the work, review it and sign it off.

314
Kotlin files
850
automated tests
306
screenshot checks
6
forms, one engine

The job

A company with more than 2,000 retail outlets sends its torque wrenches for calibration on a schedule. Each wrench moves through three stages: an initial verification, a quality review and a final verification. Until now that work was tracked in a web portal, away from the bench where it happens.

Reubro Field Pro puts the workflow on the phone. A technician sees what is assigned, enters readings in guided forms and submits them. A supervisor assigns wrenches one at a time or in bulk, reviews each submission, then approves it, returns it with a remark or sends it back a stage. Everyone can open the full history of a work order and its calibration certificate.

What I built

All of the Android app: 314 Kotlin files in Jetpack Compose and Material 3, with Hilt, type-safe Navigation Compose, Retrofit and kotlinx.serialization.

  • Two role-based shells. Supervisor and Technician each get their own tabs and back stacks behind one login.
  • One form engine for six forms. As Received, Calibration, Repair, QC, Retire and No Service share one set of rules, validation and error mapping. A rule is written once.
  • Server errors land on the right field. A validation error for reading 3 of row 2 appears on that cell, not in a toast.
  • Conflicts are handled, not hidden. If someone else changes a work order first, the app says so and offers a refresh. Nothing is saved twice.
  • Drafts survive. If Android closes the app in the middle of a form, the typed values come back.

Decisions that mattered

A mock backend inside the app. The server was still being built, so one build flavor answers every API call in-process with realistic data. The whole app could be demonstrated end to end before the first real request was ever made.

Contract tests against the API document. All 179 request and response examples in the API document are stored as fixtures and parsed by the app's own models in strict mode. When the document changes, a test fails before a user does. I also kept a log of 59 questions for the backend team, each with the assumption I built on until it was answered.

Screenshot tests for every screen. 306 reference images cover loading, empty, error and large-font states. A screen cannot change by accident.

Never send a write twice. The network client's automatic retry once re-sent a submission the server had already saved. I turned it off for writes and retry only safe reads.

Old phones, new certificate. The server's certificate chain was unknown to Android 13 and older, so every request failed on those phones. I bundled the missing root certificate instead of loosening any check.

Result

A signed release build, version 1.0.1, with R8 enabled and HTTPS only, plus a written checklist for moving from the mock backend to the live server. The app was built in 18 planned sessions over two weeks.