Freelio Is in Open Alpha

When I first wrote about Freelio in The SaaS Pivot, the goal was simple: move the messy parts of freelancing out of scattered DMs and docs into one explicit workflow.

Freelio is now in open alpha at freelio.cervelli.dev. There are still rough edges, but the core workflow is live and fully testable.

What Freelio Is (In One Sentence)

Freelio is a milestone-based freelance platform that combines contracts, proof-of-work, escrow-style payments, and dispute handling in one project timeline.

The Problem Freelio Is Built For

Most freelance projects fail for operational reasons, not technical reasons:

Scope is vague.
Payment timing is unclear.
Delivery proof is scattered.
Conflict handling is improvised.

Freelio treats those four points as first-class concerns because they are where most friction, delays, and mistrust start.

What You Can Do in Freelio Today

Browse a marketplace of creators and start a project inquiry.
Generate and sign a contract with milestones, pricing, and terms.
Track delivery per milestone with explicit proof-of-work.
Pay milestone-by-milestone with Stripe, then release funds after review.
Raise and resolve disputes in the context of the exact milestone.
Message the other party and receive in-app + email notifications.
Upload and share project files with secure links and plan-based storage limits.
Leave reviews tied to real completed projects.

Project Creation and Two-Sided Onboarding

Freelio starts from a two-party model: creator and client.

A client can hire from the marketplace or start a direct inquiry.
The project is created with explicit participants and a clear status lifecycle (inquiry -> draft -> active -> completed).
Project limits are plan-enforced, so capacity is explicit instead of silently failing later.

This structure matters because every later action (contracts, milestones, payments, disputes) inherits permissions from these roles.

Contracts: Scope, Terms, and Signature State

Before work begins, the creator can generate a structured contract:

Milestones, prices, and terms are collected into a contract payload.
A PDF view is generated for both participants.
Contract state moves from created to signed, and signature metadata is stored.
Integrity metadata (SHA-256 hash) is attached to contract records.

So the agreement is readable as a document, but still structured enough to drive UI behavior and enforce state.

The key idea is simple: remove the "start now, paperwork later" ambiguity.

Milestones and Proof-of-Work Tracking

This is where Freelio gets most opinionated.

Milestones have ordered execution and explicit states.
The creator marks a milestone completed with an optional proof link and proof description.
Sequential enforcement prevents jumping ahead when earlier milestones are still unresolved.
Clients can propose new milestones, and creators can approve or deny proposals.

I wrote about the proposal loop in Freelio Update: Streamlined Milestone Proposals. The system-level point is that scope changes now live in the same timeline as the work, instead of being negotiated in a separate chat thread.

Payments: Stripe Checkout, Escrow, and Controlled Release

Freelio uses Stripe for payment handling, but it keeps the rules of the workflow explicit:

Clients pay per milestone through Stripe Checkout.
Funds are treated as secured until release conditions are met.
Release is an explicit client action after review.
Transfers route to the creator's Stripe Connect account.

This keeps payment events aligned with delivery instead of relying on trust and reminders.

Release logic also blocks progression when constraints are violated (for example, unresolved disputes), so payment actions cannot bypass project state.

Disputes Built Into the Timeline

Disputes are not a support afterthought.

Clients can open disputes on eligible milestones.
Discussion happens in a structured revision log attached to the dispute.
Either side can add dispute messages and resolve with a resolution summary.
Payment/release paths are blocked while disputes remain open.

Conflict handling stays in the same surface as delivery and payment, which reduces context switching and missing evidence.

Messaging and Notifications

Freelio includes direct messaging between participants with conversation-level access control.

Real-time updates are pushed through a server event stream.
Conversations track unread counts and read acknowledgements.
In-app notifications are generated for key events.
Email notifications exist across contracts, milestones, payments, disputes, reviews, and messages.

There is also debounce logic for message emails, which avoids spamming users during fast chat bursts.

Assets: Project File Space and Delivery

Projects include an asset explorer tied to object storage, because deliverables should not be scattered across multiple tools.

Files upload into project-scoped paths.
Folder organization is supported.
Signed URLs are generated for secure file access/download.
Storage usage is tracked and enforced by plan limits.

This is important because deliverables are part of contractual execution, not just attachments buried in a chat.

Marketplace and Post-Project Reputation

Freelio also supports trust formation before and after delivery:

Marketplace profiles expose creator metadata, skills, and performance indicators.
Completed project data contributes to earnings and credibility signals.
Reviews are constrained to completed projects and actual participants.

Over time, this creates a reputation graph tied to real outcomes, which helps prevent detached or inflated ratings.

Why This Design Direction Matters

Freelio is not trying to be a generic all-in-one agency suite.

The current architecture is intentionally narrow:

make commitments explicit,
track delivery against those commitments,
gate money movement on verifiable state.

In other words, it turns freelance coordination from social memory into system behavior.

If you want to test the full flow today, try it at https://freelio.cervelli.dev.