Float

Landing Page
Dashboard
Incidents
AI Chat
Phone Call

Inspiration

Small businesses do not fail because they lack effort, they fail because cashflow
surprises arrive too late. We wanted to build an AI CFO that feels less like a
dashboard and more like an operator: something that can spot risk, explain what is
happening, and take action (like chasing overdue invoices) before payroll becomes a problem.

We were especially inspired by the gap between:

finance tools that only report numbers, and
actual business operations (incidents, customer delays, collections calls, payment links, follow-ups).

Float was built to close that gap.

What it does

Float is an AI CFO for small businesses that combines financial visibility, AI
analysis, and automated collections workflows.

It helps teams:

monitor cash position and runway
track payroll risk and cashflow pressure
manage invoices and overdue payments
run AI-powered debt collection calls
learn from incidents and feed those learnings back into future advice
chat with an AI assistant grounded in real account context

In short: Float turns finance + ops data into decisions and actions, not just
charts.

How we built it

We built Float as a full-stack app with:

Frontend: React + TypeScript + Vite + Tailwind + shadcn/Radix
Backend: Supabase (Auth, Postgres, Realtime, Edge Functions)
AI: Claude (streaming chat + structured outputs)
Voice automation: Twilio + ElevenLabs (real-time collections calls)
Payments: Stripe (payment links + card payment flow)

Key workflows we implemented:

Dashboard for KPIs, cashflow forecasting, and invoice visibility
AI Chat with streaming responses and business-context grounding
Calls page for overdue invoice outreach and call history
Incidents page to track operational/finance issues and surface AI learnings
Settings/Onboarding to configure business profile and connect banking (Monzo flow)
We also built multiple Supabase Edge Functions for:
chat
anomaly analysis
smart invoice chase prioritization
weekly digest generation
invoice extraction from PDFs/images
Twilio call initiation + status callbacks
Twilio ↔ ElevenLabs live audio bridge
Stripe payment link + payment processing

A core design goal was demo reliability, so we added fallback/demo data across major flows.

Challenges we ran into

Real-time voice orchestration was hard. Bridging Twilio telephony streams with
ElevenLabs conversational audio required handling websocket events, audio format
conversion, and timing issues.
Making AI outputs reliable enough for workflows. We needed structured JSON
responses (not just text) for features like smart chase, weekly digest, and
invoice extraction.
Context grounding without overloading the model. We had to carefully inject
incident and call history into chat prompts so the assistant stayed useful and
focused.
Hackathon speed vs. production correctness. We prioritized end-to-end demo flows
first, then added guardrails and fallbacks so the product remained stable even
without every integration fully configured.
Cross-system state sync. Calls, invoices, payment links, and statuses all needed
to stay consistent across Supabase, Stripe, and voice flows.

Accomplishments that we're proud of

Built a working AI CFO prototype with real frontend + backend + data model, not
just mock screens.
Implemented a Claude-powered intelligence layer across multiple workflows (chat,
anomaly analysis, invoice extraction, prioritization, weekly digest).
Shipped a Twilio + ElevenLabs real-time voice collections agent that can take
actions during calls.
Integrated Stripe into the collections loop so Float can send payment links and
track payment outcomes against invoices.
Created an incident-to-learning loop where past incidents improve future AI
guidance.
Added demo fallback mode so judges can experience the full product story even if
live credentials are unavailable.

What we learned

The biggest value is not “AI chat”; it is AI grounded in operational context.
The strongest fintech experiences come from connecting data + action:
- detect risk
- explain risk
- trigger recovery workflow
- close the loop with payment and status updates
Realtime systems (calls/incidents/invoices) dramatically improve perceived product quality.
Hackathon products move faster when we separate:
- reusable infrastructure (shared AI adapters, typed DB access)
- user-facing workflows (dashboard/chat/calls/incidents)

We also learned to express financial health in simple, actionable metrics. For
example, a rough runway estimate can be framed as:

$$ \text{Runway (months)} = \frac{\text{Cash Balance}}{\max(\text{Monthly Burn}, 1)} $$

That kind of simple model becomes much more useful when paired with incidents,
invoices, and collection actions.

What's next for Float

Ship a production-ready bank connection flow (starting with Monzo and expanding to more providers)
Improve forecasting models with better seasonality and invoice payment probability - Add collections playbooks (multi-step AI call + email + payment-link sequences)
Expand incident intelligence into preventive alerts and root-cause patterns
Harden security/compliance for payments and sensitive workflows
Build team collaboration features for finance ops (roles, approvals, audit trails)
Float started as an AI CFO prototype, but the next step is turning it into an AI
finance operations copilot that helps small businesses stay liquid, get paid faster, and make better decisions every week.