Skip to content

FieldForge

A connected field-service platform. From the first request to the work on site, approval, and payout.

Built for Buyers, dispatchers, technicians, and the teams coordinating on-site work.

Personal project · In development

FieldForge concept artwork showing a field-service dashboard and companion phone on a soft mint background.
CONCEPT VISUAL · IN DEVELOPMENTFind. Execute. Complete.
Ownership
Product direction & implementation
Timeline
Aug 2026 — Present
Project
Independent
Core stack
NestJS, Next.js, React Native, MySQL
Surfaces
Web & mobile

01 / BUSINESS CONTEXT

The problem to solve.

A service job passes from a buyer to dispatch, a technician, an approver, and billing. Scope, assignment, site evidence, and payment need to remain connected across those handoffs.

RESPONSIBILITY

My contribution

I own the product direction and implementation: work-order rules, services, shared contracts, data models, buyer portal, and technician app.

Independent project in development, with product direction and hands-on implementation owned by me.

WHAT THE SOLUTION ENABLES

A developing workflow that connects job definition, technician assignment, field evidence, approval, and billing rules.

02 / WORKFLOW SUMMARY

Follow the business process.

  1. 01

    Define & assign

    Capture the job and accept one technician’s bid.

  2. 02

    Execute

    Check in, capture evidence, and queue actions through connectivity gaps.

  3. 03

    Approve

    Authorize completion against the work-order state and supporting records.

  4. 04

    Settle

    Model payment release and invoices after approval.

03 / SOLUTION DECISIONS

Business rules, made practical.

Several technicians may bid for the same job.
Approach
Lock the work order and accepted bid together.
Why it matters
Select one winner and keep assignment consistent.
Field work continues without a reliable connection.
Approach
Queue mobile actions with identifiers and replay them in order.
Why it matters
Preserve field progress while making retries safe.
A database update and message delivery can fail separately.
Approach
Store business events with the state change, then publish them through an outbox.
Why it matters
Keep a committed business change recoverable after a messaging failure.

DELIVERY CONTEXT

In development · August 2026–present. The public repository documents the implementation. Billing uses a deterministic local ledger provider for development and tests.

ABOUT THE EVIDENCE

Website and mobile artwork illustrates the intended experience. It is concept presentation, not evidence of a production release. Kubernetes and Terraform are infrastructure exploration.

One job. A connected journey.

Explore the website, the mobile app, and the workflow that connects them.

Plan & coordinate

Technician website

A browser workspace for finding work, managing assignments, and organizing the day.

  • Job discovery, assignments, and scheduling
  • Messages, shared files, and job context
  • Earnings, credentials, and account preferences

One work-order lifecycle. These product views show the intended experience of the platform in development.

Built around the realities of field work

The core capabilities being developed, from choosing a technician to confirming the work.

Match

Location-aware dispatch

Find technicians using proximity, qualifications, and job context.

Verify

Evidence of completion

Photos, signatures, and check-in records support work approval.

Sync

Work through connectivity gaps

Queue technician actions offline and replay them in order.

Settle

Approval-led billing

Model holds and payout release around the work-order lifecycle.

Making the handoffs reliable

Explore the decisions behind assignment, execution, payment, and recovery.

01

One job, one assignment

Competing bids need a single, consistent winner.

Explore the approach

Dispatch uses Redis geospatial search to find technicians near the job location. Candidates are ranked with a deterministic score based on distance, rating, completed jobs, and certification matches.

Technicians can submit bids only for published work orders. Duplicate pending bids are blocked. Accepting a bid locks both the bid and work order before selecting the winner, rejecting competing bids, and assigning the technician.

That keeps the marketplace state clear: one accepted bid, one assigned technician, and one work order status.

02

Rules at every step

An action must be valid for the person and the current job state.

Explore the approach

Work orders move through a controlled lifecycle: draft, published, assigned, en route, on site, completed, approved, paid, cancelled, or disputed. Each transition checks the current state, caller role, and ownership before updating the order.

Database transactions and row locks protect important changes. Publishing a work order, accepting a bid, assigning a technician, and marking a job paid all update the domain record, status history, and events together.

The technician app supports travel start, check-in within a 200-meter geofence, before and after photos, serial numbers, signatures, and job completion. Offline actions are queued locally with idempotency keys and replayed in order when the device reconnects.

03

Safe payment retries

Repeated requests must not create repeated payouts.

Explore the approach

Billing is modeled around escrow-style holds. A buyer can lock funds for a work order, and funds can be released only after the work is approved by an authorized user.

The release path uses idempotency records, row locking, and a single escrow account per work order to prevent duplicate payouts. It records payout ledger entries, generates invoice data, and can refund unused escrow balance when the final payout is lower than the held amount.

Payment provider behavior sits behind an interface, with a deterministic ledger provider for local development and tests. That keeps billing rules testable without depending on a live provider.

04

Recoverable events

A temporary messaging failure should not lose a business change.

Explore the approach

Work-order and billing services write domain events into an outbox inside the same transaction as the business change. A relay publishes those stored events to RabbitMQ after commit, so a broker failure does not erase the business event.

The outbox relay claims small batches with row locking, uses expiring leases and claim tokens for recovery, keeps events ordered per aggregate, applies publish timeouts, retries temporary failures with backoff, and marks malformed payloads as dead.

Consumers use Redis-backed event deduplication, keep correlation IDs, retry failed handlers a limited number of times, and route exhausted attempts to dead-letter queues.

Shared rules behind every experience

The applications connect through an API gateway, domain services, and a shared event model.

Web & mobile

Next.js web portal

React Native / Expo app

Shared TypeScript contracts

Domain services

Gateway & authentication

Work orders & dispatch

Billing & notifications

Data & events

MySQL / Drizzle

Redis location & deduplication

RabbitMQ / transactional outbox

Explore technical decisions

FieldForge is organized as a Turborepo with NestJS services behind an API gateway, shared TypeScript contracts, MySQL tables, Redis for location and deduplication, RabbitMQ for events, a Next.js buyer portal, and a React Native mobile app.

Docker Compose supports local development. Kubernetes/Kustomize and Terraform definitions are included for infrastructure modeling.

The service boundaries follow the hard parts of the domain: work-order state, billing state, dispatch decisions, async events, and client workflows.

Implementation toolkit

  • NestJS
  • TypeScript
  • MySQL
  • Drizzle
  • Redis
  • RabbitMQ
  • Next.js
  • Redux Toolkit
  • React Native
  • Expo
  • Turborepo
  • Docker Compose

Have a service workflow to connect?

Let’s turn the problem into a clear plan, a useful product, and a path to launch.