ProofOps turns industrial maintenance into verifiable outcomes: Ai checks private repair evidence, humans approve the work, and smart contracts release protected payments only after proof.
Industrial maintenance has a trust problem.
When a factory hires a technician to repair critical equipment, proof of completion is usually scattered across photos, PDFs, sensor readings, checklists, emails, chats, and invoices. Supervisors manually reconcile that evidence, contractors wait for approval, disputes are difficult to resolve, and the final payment is disconnected from whether the work was actually proven.
ProofOps turns that fragmented process into one verifiable workflow.
It is an AI-assisted industrial maintenance and settlement platform where:
the factory defines the work → payment is protected in escrow → the technician submits private evidence → Ai verifies the evidence → a human supervisor makes the final decision → the smart contract releases payment → the equipment receives a tamper-evident service record.
Consider a conveyor motor operating at 94°C when its safe threshold is 70°C.
The factory can hire a technician to repair it, but several questions remain:
Was the correct machine serviced?
Was the required component actually replaced?
Do the before-and-after photographs match the work order?
Does the maintenance report agree with the visual evidence?
Did the sensor readings actually improve?
Who approved the completed work?
Can the contractor prove that payment was promised?
Can an auditor later verify what happened without trusting an editable spreadsheet?
Today, these are usually separate problems handled by separate systems.
ProofOps connects them.
A factory manager creates a structured maintenance work order against an existing equipment asset or registers a new asset.
The manager defines:
repair scope
mandatory evidence
technician
supervisor
deadline
checklist requirements
expected sensor outcome
contractor payment
Before work begins, the manager funds the payment into a Base Sepolia smart-contract escrow using ProofOps demo pUSDC.
This creates an important two-sided guarantee:
The technician knows the payment has been secured.
The factory knows it cannot be released through the normal workflow until evidence has been submitted, verification has been recorded, and the assigned supervisor approves.
The technician receives the assigned job through a dedicated technician dashboard.
Before evidence submission, ProofOps verifies the equipment identity through its QR-linked asset record.
The technician then submits the complete maintenance evidence package:
before images
after images
component photographs
signed maintenance report
before/after sensor readings
required safety checklist
technician notes
Raw industrial evidence remains private.
ProofOps hashes each evidence file and creates a deterministic fingerprint of the final evidence package. Only this cryptographic proof is anchored into the blockchain workflow not private factory photographs, documents, storage URLs, or personal information.
This gives us:
Private evidence. Publicly verifiable proof.
Once evidence is submitted, the job enters the supervisor verification queue.
Gemini performs multimodal analysis across the submitted maintenance evidence and evaluates:
equipment identity
before/after image consistency
component changes
maintenance report contents
required work completion
checklist completion
sensor readings
contradictions
missing evidence
risk flags
AI output is converted into structured verification results instead of an unbounded chat response.
ProofOps then applies deterministic application logic around the AI result and creates a canonical verification report that can itself be cryptographically hashed.
Most importantly:
Gemini does not control payment.
If evidence is blurry, incomplete, contradictory, or uncertain, the system can surface that uncertainty instead of silently treating the work as valid.
AI is used for what it is good at rapidly understanding fragmented evidence.
It is not used as the final authority.
Industrial work has safety, financial, and operational consequences.
That is why ProofOps is intentionally human-in-the-loop.
The assigned supervisor receives Gemini's findings together with the original supporting evidence and can:
inspect every requirement
review evidence references
evaluate AI confidence
override individual findings
add a review note
approve the work
request correction
raise a dispute
The human supervisor remains responsible for the final decision.
This is central to our Industrial 5.0 approach:
AI increases human capability rather than removing human accountability.
After evidence exists and verification has been recorded, the supervisor can approve the completed work.
The ProofOps escrow contract then releases the protected pUSDC payment directly to the assigned technician.
The contract enforces the workflow through explicit roles and states.
It prevents actions such as:
unauthorized evidence submission
unauthorized verification
payment without evidence
payment without a verification report
double settlement
settlement while disputed
duplicate work-order identifiers
If a dispute is raised, settlement is blocked and the dispute must follow the contract's resolution flow.
Blockchain is therefore not being used simply because this is a Web3 hackathon.
It solves the part of the problem that requires shared trust and enforceable settlement between organizations that may not share the same internal database.
When payment is successfully released, ProofOps records a maintenance event against the equipment's on-chain passport.
The passport contains minimal cryptographic proof such as:
equipment hash
work-order identifier hash
evidence hash
AI report hash
technician
supervisor
verification score
timestamp
escrow reference
The underlying private evidence remains off-chain.
This creates a tamper-evident maintenance lineage that could be useful to:
factory operators
maintenance contractors
auditors
insurers
equipment manufacturers
future asset owners
Instead of saying:
"Trust our database - this machine was maintained."
ProofOps enables:
"Here is the evidence fingerprint, approval trail, settlement event, and asset history. Verify it."
ProofOps deliberately gives each layer one clear responsibility.
Understands messy real-world evidence.
Provides judgment and accountability.
Protects identity, operational data, and private evidence.
Provides shared transaction state and settlement.
Enforce payment rules and prevent unilateral changes to the settlement workflow.
Preserves minimal tamper-evident maintenance history.
No technology exists merely as a badge.
Each solves a different trust problem.
Industrial 5.0 is not simply about replacing workers with automation.
ProofOps is built around collaboration between workers, AI, cloud infrastructure, and programmable settlement.
It supports:
Human-centric operations
Technicians and supervisors remain active participants rather than being replaced by autonomous agents.
AI-assisted productivity
Gemini reduces the effort required to compare images, reports, requirements, and sensor data.
Smarter industrial workflows
Maintenance moves through a structured lifecycle instead of disconnected communication channels.
Safer operations
Work requirements, evidence, measurements, and human approval remain visible and auditable.
Digital finance and settlement
Contractor payment becomes directly connected to the verified maintenance workflow.
Web2 → Web3 adoption
Users interact with a familiar operational dashboard while blockchain is used only where shared verification and settlement create real value.
ProofOps is a functional end-to-end product rather than a static concept.
The current prototype includes:
organization dashboard
equipment management
work-order creation
technician and supervisor assignment
requirement definition
payment configuration
equipment passport registration
pUSDC faucet support
token approval
on-chain work-order creation
escrow funding
blockchain/database synchronization
assigned-job dashboard
equipment QR verification
private evidence upload
before/after images
component evidence
service report upload
sensor readings
safety checklist
SHA-256 evidence hashing
canonical evidence-package hashing
on-chain evidence submission
verification queue
Gemini multimodal verification
structured requirement results
confidence and risk findings
evidence review
human overrides
approval notes
correction requests
disputes
on-chain verification recording
escrow settlement
equipment passports
payment status
blockchain transaction records
work-order lifecycle
activity timeline
evidence hashes
AI report hashes
ProofOps is built as a cloud-native full-stack application using:
Frontend & Application
Next.js, React, TypeScript, Tailwind CSS
Database & Private Evidence
Supabase PostgreSQL, Authentication, Row Level Security, and private Storage
AI
Gemini multimodal verification with structured output and server-side execution
Blockchain
Solidity smart contracts deployed on Base Sepolia
Contracts
WorkOrderEscrow
EquipmentPassport
ProofOps Demo USDC (pUSDC)
Web3 Integration
Wagmi + Viem
Contract Development
Hardhat 3 + Hardhat Ignition + OpenZeppelin
Deployment
Vercel
The blockchain remains the source of truth for settlement state, while Supabase manages private operational information.
ProofOps deliberately avoids putting sensitive industrial information on a public chain.
Raw images, reports, filenames, private URLs, and personal information remain off-chain.
Only minimal hashes and settlement state are anchored on-chain.
Additional safeguards include:
role-based application access
Supabase Row Level Security
private evidence storage
short-lived evidence access
server-side Gemini execution
structured AI output validation
deterministic verification logic
human approval before payment
SafeERC20 transfers
reentrancy protection
explicit contract state transitions
dispute blocking
transaction receipt confirmation before database synchronization
ProofOps begins with industrial maintenance, but the underlying model is broader:
define work → protect value → prove work → verify evidence → human approval → settle → preserve history
The same infrastructure could extend to:
solar maintenance
HVAC servicing
industrial inspections
construction milestones
equipment installation
electrical maintenance
logistics inspections
warranty servicing
field-service contractors
Our goal is not to tokenize industrial maintenance.
Our goal is to build a trust layer between physical work and digital settlement.
ProofOps gives factories confidence that approved work has supporting proof, gives technicians stronger payment assurance, and creates verifiable maintenance records for organizations that otherwise have to trust fragmented internal systems.
ProofOps - Work proven. Payment protected. History preserved.
During ChainHack, we took ProofOps from the initial product concept to a working end-to-end Industrial 5.0 prototype.
We built the complete three-role maintenance workflow across Factory Manager, Technician, and Supervisor rather than demonstrating isolated AI or blockchain components.
We designed and implemented:
ProofOps public landing experience
role-based authentication
manager command center
technician workspace
supervisor verification queue
work-order lifecycle
equipment management
payment dashboard
activity/audit trail
equipment passport views
responsive production UI
We implemented the complete maintenance lifecycle:
Create → Fund → Repair → Submit Evidence → AI Verify → Human Review → Settle → Record
Managers can create maintenance work orders, assign workers, define evidence requirements and protect payment.
Technicians can verify equipment, upload private maintenance evidence, enter sensor readings and complete required checklists.
Supervisors can inspect the resulting evidence, run Gemini verification, override AI findings and make the final approval decision.
We integrated Gemini into the real supervisor workflow.
The AI pipeline analyzes:
before/after images
equipment identity
maintenance reports
requirement completion
sensor readings
contradictions
missing evidence
risk flags
AI responses are validated as structured data and converted into an auditable verification result.
AI is intentionally not allowed to release funds - human approval remains mandatory.
We implemented private evidence storage using Supabase and built deterministic cryptographic evidence hashing.
Raw industrial evidence remains private.
The blockchain receives only minimal hashes and settlement information, allowing ProofOps to preserve verifiability without exposing sensitive operational data.
We built and integrated three Solidity contracts:
WorkOrderEscrow
Protects contractor payment and enforces the work-order state machine.
EquipmentPassport
Records minimal tamper-evident maintenance events for registered equipment.
ProofOps Demo USDC (pUSDC)
A six-decimal Base Sepolia-only faucet token with no real-world value, used to demonstrate the settlement workflow safely.
The escrow contract includes:
role validation
protected funding
evidence-hash submission
verification-hash recording
supervisor-controlled release
dispute handling
duplicate settlement protection
deadline behavior
SafeERC20 transfers
reentrancy protection
We deployed the Web3 workflow to Base Sepolia and connected it directly to the frontend using Wagmi and Viem.
The product handles:
wallet connection
network validation
equipment registration
pUSDC faucet
token allowance
work-order creation
escrow funding
evidence proof submission
verification proof recording
payment release
transaction confirmation
contract/database reconciliation
explorer links
We implemented:
Supabase Auth
PostgreSQL schema
Row Level Security
private evidence storage
role-based authorization
server-side Gemini calls
structured input/output validation
deterministic evidence hashing
blockchain state reconciliation
environment-secret separation
We built ProofOps using:
Next.js + TypeScript + Supabase + Gemini + Solidity + Hardhat + OpenZeppelin + Wagmi + Viem + Base Sepolia.
The application is deployed through Vercel and the smart-contract deployment is reproducible through Hardhat Ignition.
By the end of the hackathon, ProofOps became a working prototype capable of demonstrating the complete journey of one real industrial maintenance job:
a machine requires repair → the factory protects payment → the technician proves the work → Gemini verifies the evidence → a human supervisor approves → the smart contract pays the technician → the equipment receives a tamper-evident maintenance record.
That full lifecycle is the core achievement of our ChainHack build.