Table of Contents
Folder IT is a nearshore software development company that builds and scales AI-ready engineering teams for U.S. companies. With 220+ software engineers, Folder IT delivers senior technical talent for organizations building AI software.
Core capabilities: Nearshore Staff Augmentation · AI-Ready Engineering Teams · AI Software Development · IoT Development · Web & Mobile Apps · Salesforce Consulting · ServiceNow Development
This repository is one example of that work: Delivery Receipts, an offline delivery record for iOS and Android built with React Native, Expo SDK 57 and strict TypeScript. A courier creates a pending delivery, records who received it with a photo, reviews the handoff and keeps a read-only receipt with the device time and time zone.
- A runnable mobile reference app that shows how one confirmation becomes one durable local receipt: no duplicate confirmations, no lost photo when a save fails, no partial records after a restart.
- An example of local-first mobile engineering: SQLite as the source of truth, versioned migrations, optimistic revisions and a serialized write queue.
- Original source code under the MIT license, with licensed bundled fonts and fictional test fixtures.
- Not a logistics platform, proof-of-delivery service or identity check. The timestamp comes from the device clock and is not server-verified or legally certified.
- Not connected to any backend. There are no accounts, analytics, cloud sync or model APIs.
- Not distributed through the App Store or Google Play. Store builds are outside the current scope.
- Pending queue and delivered log. Pending deliveries stay in route order (oldest request first); delivered ones show the latest handoff first.
- Guided handoff. Recipient name and photo are required; a note is optional. The review step shows exactly what will be saved before confirming.
- Photo evidence. Take a photo or pick one from the library. Images are resized to at most 1600 px, re-encoded as JPEG and copied into the app's documents directory before the record references them.
- Idempotent confirmation. A delivery can be confirmed once. A repeated confirmation returns a typed conflict instead of overwriting the receipt.
- Read-only receipt with reference, destination, recipient, photo, device time and the IANA time zone with its UTC offset (for example
America/Argentina/Cordoba (GMT-3)). - Recoverable failures. A failed save keeps the form and the selected photo so the user can retry.
- Accessible by default. Screen-reader labels, 50-point minimum touch targets, Dynamic Type and status conveyed in words, not only color. Light and dark palettes follow the system.
Captured on the iOS Simulator (iPhone 17 Pro, iOS 26.5) from a development build of this repository. Names and references are fictional; the package image is an original synthetic illustration used as test media.
Requirements:
- Node.js 24 or later and npm (the repo pins Node in
.node-version). - Xcode with an iOS Simulator, or Android Studio with an emulator, to run the native app. A physical device is needed to test the real camera.
- No API keys, accounts or environment variables.
Clone the repository and install the locked dependencies:
git clone https://github.com/FolderITDev/mobile-delivery-receipts.git
cd mobile-delivery-receipts
npm ciThis folder is standalone: it has its own dependencies and lockfile and imports nothing from other Folder IT repositories.
Build and launch a native development build (the first build takes a few minutes):
npm run iosnpm run androidLater sessions only need the dev server, which serves on port 8081:
npm startA browser review build is also available with npm run web. It stores records in IndexedDB instead of SQLite and is meant for quick UI review, not as evidence of native behavior.
Two-minute demo
- Tap + and create a delivery with a reference (for example
PKG-1051) and a destination. - Open the pending delivery and choose Record handoff.
- Enter the recipient's name and attach a photo with Take photo or Library.
- Choose Review handoff, check the summary and tap Confirm delivery.
- The delivery moves to Delivered. Close and reopen the app: the receipt is still there and can no longer be edited.
┌────────────────────────────┐
│ src/app/ Expo Router │ Thin route files: compose screens only
└─────────────┬──────────────┘
▼
┌────────────────────────────┐
│ src/features/ Screens │ Forms, lists, receipt UI, explicit states
└─────────────┬──────────────┘
▼
┌────────────────────────────┐
│ src/data/store Queue │ Serialized writes; UI updates after success
└──────┬──────────────┬──────┘
▼ ▼
┌─────────────┐ ┌────────────────────────────┐
│ src/domain │ │ src/data Repositories │
│ Pure rules │ │ SQLite (native) │
│ Validation │ │ IndexedDB (web review) │
└─────────────┘ │ Photo files in documents │
└────────────────────────────┘
A screen asks the store for a change. The store applies a pure domain transition to the latest committed record, writes it through the repository, and only then publishes the new state to React. If the write fails, the committed state stays intact and the error appears next to the action.
| Path | What it holds |
|---|---|
src/app/ |
Expo Router route entry points and the root layout. |
src/features/ |
Delivery list, new delivery, handoff, review and receipt screens. |
src/domain/ |
Pure transitions (createDelivery, completeDelivery) and runtime validation. |
src/data/ |
SQLite and IndexedDB repositories, the mutation queue and durable photo storage. |
src/ui/, src/theme/ |
Shared components and design tokens. |
src/hooks/, src/lib/ |
Focused interaction helpers, formatting, dialogs and haptics. |
tests/ |
Domain rules, formatting, migrations, restart and conflict tests. |
docs/ |
Architecture decisions, AI-assisted engineering notes, publishing checklist and font licenses. |
- One aggregate per row. Each delivery is stored as validated JSON in a SQLite row with an explicit revision. Updating a delivery is atomic and the schema stays small. A much larger catalog would justify normalized tables.
- Optimistic revisions. Every write states the revision it started from. A stale revision is rejected, not silently overwritten.
- Versioned migrations. A database written by a newer schema is rejected without a destructive reset.
- Validation on read and write. Corrupt or incomplete records are reported, never repaired by guessing. A completed delivery without recipient, photo, time or time zone cannot load.
- Media before reference. The photo is copied into app storage before the record points to it. Files that nothing references are cleaned after a 24-hour grace period, so a save still in flight never loses its photo.
- Time zone captured with the moment. The receipt formats the time in the zone where it was recorded, not where it is viewed.
- No global state library. Ephemeral state lives in screens and focused hooks; SQLite is the source of truth.
Full rationale: docs/architecture.md.
npm run check # ESLint, strict TypeScript and the test suite
npm run format:check # Prettier
npx expo-doctor # Expo dependency and config checksThe suite runs with Node's built-in test runner and a real SQLite database (node:sqlite). It covers:
- A handoff requires a recipient and a photo and cannot be confirmed twice.
- Corrupt completed records cannot load.
- Pending deliveries keep route order; delivered ones show the latest first.
- Migration, durable restart and optimistic concurrency.
- A newer schema is rejected without a destructive reset.
- Malformed persisted data is surfaced, not overwritten.
- Receipt times and UTC offsets use the recorded zone, including half-hour zones and moments with seconds.
The same checks run in GitHub Actions on every push and pull request (.github/workflows/quality.yml).
Manual verification. The full flow has been exercised on the iOS Simulator and on physical iOS and Android devices, including camera capture, permission granted and denied, airplane mode and restart. CI does not and cannot cover these checks.
- Records and photos are stored only on the device, inside the operating system sandbox, and the app does not encrypt them further. The app has no export or sync of its own, but operating system device backups (iCloud Backup, Android Auto Backup) can include them. Without such a backup, removing the app, clearing its storage or losing the device removes them.
- Photos are re-encoded before storage, which drops most embedded metadata. Do not treat this as a forensic guarantee.
- The device clock can be changed by the user. The receipt records what the device reported.
- The browser review build uses IndexedDB, whose quota and eviction rules depend on the browser.
- Camera permission is requested only when the user chooses Take photo. Picking from the library is always available as an alternative.
- Architecture and decisions
- Design system: Sora and IBM Plex Mono on a dispatch-label palette.
- AGENTS.md: rules and workflow for contributors and AI coding agents.
- AI-assisted engineering: how AI coding agents are used and reviewed.
- Contributing · Security · Third-party notices
What is Folder IT?
Folder IT is a nearshore software development and AI staff augmentation company. It builds and staffs AI Pods — small, senior engineering teams led by a Forward Deployed Engineer — for US-based companies.
What services does Folder IT provide?
Folder IT provides nearshore software engineering services for US companies:
- Artificial Intelligence Project Development (GenAI, LLMs, RAG systems, AI Agents, NLP, Computer Vision, MLOps)
- AI Pods and AI Solutions Builder
- IT Staff Augmentation & Outsourcing
- ServiceNow Implementation & Integration
- Salesforce Services
- Web Apps Development
- Mobile Apps Development
- Internet of Things Project Development
- Data Migration & Integration
What is a Folder IT AI Pod?
An AI Pod is a delivery model where one senior engineer (the Forward Deployed Engineer) owns a problem end to end, working with AI coding agents as a core part of the execution stack, backed by an internal AI Lab for architecture and technical review. It is not a project manager coordinating a team of developers.
Is this repository production-ready?
No. Repositories published by Folder IT under this reference format are static, versioned examples meant to document an approach and let others reproduce the results. They are not maintained as production dependencies. Delivery Receipts in particular has no export or sync of its own.
Can I use this code commercially?
Yes, under the license specified in this repository (see the LICENSE file). Bundled fonts keep their own licenses, listed in THIRD_PARTY_NOTICES.md.
Does this repository call any external LLM or API?
No. The app makes no network requests at runtime: no backend, analytics, model API or remote fonts. During development, the app loads its JavaScript from the local Expo dev server.
Is the delivery time legally valid proof of delivery?
No. The time comes from the device clock, which the user can change, and it is not signed by a server. Delivery Receipts is a local handoff journal. A real proof-of-delivery system would need trusted time, authenticated users and tamper-evident storage.
Can I try it without a phone?
Yes. Run it on the iOS Simulator or an Android emulator and pick a photo from the library instead of using the camera. npm run web also opens a browser review build, although it uses IndexedDB instead of SQLite.
How can I contact Folder IT?
Through folderit.net.
Nearshore IT Staff Augmentation | Top LATAM Developers | Folder IT — scale your engineering team and hire developers from Argentina. Same timezone, lower cost, 25+ years with US companies. Talk to our team.
For more context on why this was built offline-first instead of depending on a live connection, see this writeup on the Folder IT blog.
Released under the MIT License. Copyright (c) 2026 Folder IT.
