Gig workers lose income for reasons they cannot control: heavy rain, platform outages, curfews, poor air quality, and local disruptions. Most traditional claim systems are slow, manual, and stressful at the exact moment people need help.
I built GigShield to explore a different approach: parametric protection that can trigger payouts automatically when predefined external conditions are met, with fraud controls and verification built into the flow.
The product idea
GigShield is designed around one simple promise: if covered disruption conditions happen, workers should know quickly whether they are eligible and how much they will receive.
The app includes:
- Tiered weekly plans with clear coverage limits
- Trigger-based payout logic (weather, platform, and social disruptions)
- A transparent decision flow with explicit reason codes
- Fraud checks before settlement for risky claims
- A full payout lifecycle from event detection to receipt
Why this was interesting to build
Most demos stop at UI. I wanted this one to model real decision mechanics:
- Policy domains and exclusions
- Coverage-hour checks
- Daily caps by plan
- Trigger confidence and cooldown windows
- Verification gates for high-risk claims
This made the project less like a landing page and more like a small rules-driven system.
Architecture in practice
The stack is React + Vite + Tailwind, with utility modules that isolate policy, payout, fraud, observability, and integrations concerns. Routes are separated by persona and workflow: onboarding, dashboard, payout, history, fraud explainability, and admin operations.
A key design choice was frontend-first state with local persistence. That made iteration fast and let me simulate full flows end-to-end without waiting on backend dependencies. Supabase auth and schema scaffolding are present, but most operational logic currently runs client-side for demo velocity.
Trade-off: speed of development vs tamper resistance and production-grade trust boundaries.
Fraud and trust layer
The most important part was preventing blind auto-payouts. GigShield includes several controls:
Risk scoring that classifies users into low, medium, high risk
Conditional verification for high-risk payout attempts
Device fingerprinting for repeated-attempt detection
Velocity limits to block rapid abuse loops
Geo-consistency checks against expected service location
Liveness challenge flow with selfie + gesture prompts
Even in a demo environment, this created realistic friction only where needed.
Payout lifecycle design
Instead of a single “success/fail” event, payouts move through explicit states:
- Pending verification
- Verified
- Processing
- Settled or failed
That state machine made it easier to debug behavior, generate history views, and provide clear UI feedback. It also allowed reason-code driven outcomes such as coverage inactive, cap reached, policy excluded, or verification required.
What I tested
I added tests around the pieces most likely to break business trust:
Risk score to risk level mapping
Plan cap and payout capping behavior
Security checks like velocity and geo guardrails
End-to-end payout flow transitions under different scenarios
This gave me confidence that “looks correct” in UI also means “behaves correctly” in logic.
Top comments (0)