Gigly

Freelancing without the 20% cut or fake reviews. Gigly uses smart escrows, a secure sandbox, and on-chain reputation so you never get scammed and always get what you paid for.

Comment

Gigly — Trustless Freelancing Powered by Blockchain

Inspiration

The Freelancer Tax

As student developers exploring freelancing, we repeatedly encountered the same obstacles: high platform commissions, delayed bank transfers, and expensive foreign exchange fees on international payments. Traditional freelancing platforms often take a significant cut of freelancers' earnings, making it harder for newcomers to earn fairly from their work.

The "Work First, Hope You Get Paid" Trap

Handing over complete source code or design files before payment clears is terrifying. Freelancers risk having their intellectual property stolen, getting ghosted by clients, and losing both their work and their earnings, especially when dealing with clients across borders.

Reputation Monopoly

Traditional platforms lock freelancers' reputations inside their own ecosystems. Meanwhile, fake five-star reviews make it difficult for genuinely talented freshers to establish credibility and secure their first contracts.

Algorithmic Trust Over Legal Paperwork

We wanted to transform cross-border trust from a gamble into code. That's why we built Gigly — a blockchain-powered freelancing platform designed to make gig work more secure through stablecoin escrow, tamper-resistant credentials, and protected deliverable sandboxes.

Our vision is simple: freelancers should be able to focus on delivering great work without constantly worrying about whether they will get paid.

What It Does

1. Optimistic USDC Escrow

Clients lock USDC into an on-chain smart contract before work begins.

Once the freelancer submits a milestone, a review window starts. If the client approves the deliverables, the funds are released. If the client becomes unresponsive, the contract can automatically release the funds according to its predefined settlement rules.

This creates a transparent payment process without requiring freelancers to blindly trust clients.

2. Two-Tier Deliverable Sandbox

Gigly protects freelancers' intellectual property through a two-tier submission system.

Freelancers submit two links:

  • Preview URL: A view-only version of the deliverable that clients can inspect inside a watermarked, click-protected sandbox.
  • Master Source Asset: The original source code or design files, which remain hidden until the client signs the release transaction.

This allows clients to review completed work while preventing premature access to the original assets.

3. Soulbound Proof-of-Work (SBTs)

Successful gig completions generate non-transferable ERC-721 credentials directly in the freelancer's wallet.

These Soulbound Tokens (SBTs) serve as on-chain proof of completed work, helping freelancers build a portable reputation that is not tied exclusively to a centralized platform.

Because the credentials are non-transferable, they cannot simply be bought or sold like ordinary tokens.

4. Fresher Capability Launchpad

Our intelligent matching engine scans open gig titles and scopes, identifies the required skills, and compares them against a developer's verified skill profile.

It produces a capability match score along with a breakdown of missing skills, helping freshers discover opportunities that align with their current abilities and identify areas for improvement.

5. Decentralized Dispute Jury & NDC Protocol

Before a dispute escalates, both parties must complete an on-chain Non-Dispute Consent (NDC) modal.

If the parties cannot reach consensus, high-reputation peer freelancers can arbitrate the deliverables through decentralized voting.

This replaces reliance on a centralized customer-support process with a transparent, community-based dispute-resolution mechanism.

6. Dynamic Protocol Admin Panel

Protocol owners can manage key platform parameters through a wallet-gated administrative interface.

The dashboard supports:

  • Configuring escrow review windows.
  • Managing platform fee basis points.
  • Monitoring dispute resolutions.
  • Interacting with protocol administration functions through a connected wallet.

How We Built It

Frontend & UX

We built the frontend using:

  • Next.js 14 with the App Router.
  • TypeScript.
  • Tailwind CSS.
  • Thirdweb v5 for unified wallet connections, IPFS metadata pinning, and type-safe smart-contract hooks.

The application provides dedicated freelancer and client dashboard experiences, with wallet interactions integrated into the core workflow.

Smart Contracts

Our smart contracts were written in Solidity 0.8.24 and compiled using Hardhat. We deployed and tested the contracts on the Sepolia testnet.

The core contracts include:

  • OptimisticEscrow.sol — Handles fund locking, time-based review windows, and settlement.
  • GiglyCredential.sol — Implements Soulbound credentials by overriding the OpenZeppelin v5 _update hook to enforce non-transferability.

Database & Off-Chain Storage

We use Supabase to manage:

  • Developer profiles.
  • Capability tags.
  • Metadata caching.
  • Search-related application data.

This off-chain layer supports responsive profile discovery and efficient matching without placing every piece of application data on-chain.

Capability Match Engine

We implemented a client-side set-intersection algorithm to calculate how well a freelancer's skills match a gig's requirements.

Let:

  • (S_{user}) represent the normalized set of skills in the freelancer's profile.
  • (S_{task}) represent the set of skills detected as necessary for the gig.

The capability match score is calculated as:

$$ M = \left( \frac{|S_{user} \cap S_{task}|}{|S_{task}|} \right) \times 100 $$

To prevent division-by-zero errors when a gig has a generic title or no detectable skills, the engine applies a fallback classifier:

$$ \text{If } |S_{task}| = 0 \implies M = 75\% $$

The task is then classified as:

General Starter Task

This fallback allows generic opportunities to remain discoverable instead of causing the matching engine to fail.

Challenges We Ran Into

1. The Iframe "Sad Document" Crash

We wanted staging applications hosted on platforms such as Vercel and Netlify to render directly inside our watermarked preview sandbox.

However, restrictive security headers such as X-Frame-Options: SAMEORIGIN and Content Security Policies prevented certain external applications from being embedded, causing browser rendering failures.

How we addressed it: We built a hybrid viewer that attempts sandboxed rendering when embedding is permitted and provides a clean external-tab fallback when the target application blocks iframe access.

2. The Web3 Timestamp Mismatch

Our review countdown timer initially displayed "Time expired" immediately after a freelancer submitted a deliverable.

The underlying issue was a unit mismatch:

  • Solidity's block.timestamp uses seconds.
  • JavaScript's Date.now() returns milliseconds.

How we addressed it: We implemented a time-normalization hook to convert timestamps into consistent units before performing countdown calculations.

3. Skill Extraction Word Boundaries

Our initial keyword-matching implementation generated false positives. For example, searching for Go could accidentally match part of Good, while searching for Java could incorrectly match JavaScript.

How we addressed it: We refactored the extraction engine to use regular-expression word boundaries (\b) and introduced an alias-normalization dictionary to improve skill recognition.

4. Dynamic Storage Layout Shifts

Transitioning from hardcoded contract variables to a configurable administration dashboard introduced storage-layout concerns during development.

How we addressed it: We created dedicated migration scripts, including deploy_upgraded_escrow.ts, to support clean redeployment to Sepolia and synchronize the frontend with the updated contract ABIs.

Accomplishments That We're Proud Of

Complete End-to-End Escrow Cycle

We successfully built, deployed, and tested a complete milestone workflow:

  1. Locking USDC in escrow.
  2. Submitting sandboxed deliverables.
  3. Verifying the review countdown.
  4. Releasing funds through a single-click settlement flow.
  5. Automatically minting an SBT credential upon successful completion.

Protecting Intellectual Property Without IPFS Bloat

Rather than forcing massive codebases into decentralized file storage, we implemented a two-tier preview/original URL architecture.

This approach allows freelancers to share reviewable work while keeping the original source assets protected until release.

Decentralized Adjudication

We replaced a conventional centralized support-ticket approach with a peer-review jury system supported by an explicit pre-dispute consent process.

Full-Stack Integration

We integrated our frontend, smart contracts, wallet interactions, and freelancer/client dashboard states into a unified application using Thirdweb v5.

Keeping the contract logic focused while synchronizing on-chain and off-chain application state was a significant engineering milestone.

What We Learned

Security Is a UX Challenge

Preventing scams involves more than implementing reentrancy guards and secure Solidity functions. It also requires carefully designed user interactions.

Building the NDC modal taught us the importance of deliberate confirmation flows before users execute consequential on-chain actions.

OpenZeppelin v5 Architecture

Migrating to OpenZeppelin v5 helped us understand how its unified _update function can simplify the implementation of minting, burning, and Soulbound non-transferability.

Defensive Frontend Engineering

When working with decentralized applications and external resources, we learned never to assume that an external link, wallet connection, or on-chain call will succeed.

Loading skeletons, fallback layouts, error boundaries, and clear transaction states are essential for building a reliable user experience.

What's Next for Gigly?

1. Layer-2 Rollup Migration

We plan to deploy our escrow contracts on a Layer-2 network such as Base, Arbitrum, or Polygon to reduce transaction costs.

Our target is to bring transaction fees below $0.01 where network conditions permit, making low-value micro-gigs more economically viable.

2. Fiat On/Off-Ramp Integration

We plan to integrate payment providers such as Transak or MoonPay so that non-crypto-native clients can fund escrows using credit cards.

We also aim to simplify the withdrawal experience for international freelancers by supporting fiat off-ramps to local bank accounts.

3. Commit-Reveal Jury Staking

We intend to expand our peer-jury system by introducing:

  • Juror staking.
  • Slashing mechanisms for proven collusion.
  • Rewards for honest participation.
  • Cryptographically sealed commit-reveal voting.

These mechanisms would be designed to strengthen the integrity of decentralized dispute resolution.

4. Mobile-Responsive Progressive Web App

We plan to package Gigly as a progressive web app with a mobile-first dashboard experience and push notifications.

This would allow freelancers and clients to receive timely alerts about milestone submissions, review windows, and important escrow events.

Built for Freelancers. Powered by Trust.

Gigly brings together blockchain escrow, protected deliverables, portable credentials, and decentralized dispute resolution to address the trust challenges of modern freelancing.

By combining smart-contract guarantees with thoughtful user experience design, we aim to create a more transparent environment where freelancers can build their reputations, protect their work, and get paid according to clearly defined rules.

Gigly — Work with confidence. Get paid with trust.

Built With

Share this project:

Updates

Submission history