Chazer

We built Chazer for freelancers and agencies who hate chasing late payments. It handles polite-to-firm follow-ups automatically while keeping you in control.

Comment

Inspiration

Every freelancer and agency lead knows the exact feeling: you wrap a killer project, hit “Send Invoice,” and instantly enter a 30-day holding pattern of social dread.

You know the money is overdue. You know you should follow up. But manual collections feel deeply uncomfortable—push too hard and you jeopardize a valuable client relationship; play it too soft and you end up personally bankrolling their cash flow.

For independent contractors, this isn't just an administrative headache. When the median freelancer earns $45k a year, a single ghosted $4,000 invoice eats nearly 10% of their annual income.

Traditional billing tools completely miss the mark here. They fire mindless, generic reminder templates on fixed cron schedules. They cannot read the room, they cannot detect when a client is asking for net-60 terms versus contesting a line item, and they possess zero nuance. We built Chazer to solve the actual friction: taking the awkward social tax out of getting paid while keeping the human firmly in control of the high-stakes moments.

What it does

Chazer is an autonomous invoice-chasing engine designed to recover revenue without alienating clients. Instead of blasting repetitive boilerplate, it runs an intelligent, context-driven escalation ladder:

  • Tier 1 (Days 1–7): Sends a low-friction, friendly nudge that feels like a natural human check-in.
  • Tier 2 (Days 8–21): Steps up firmness, dynamically referencing prior touchpoints so the client knows it's on the radar.
  • Tier 3 (Days 22+) & High-Value / Disputes: Automation deliberately stops. The system drafts a context-aware final notice or resolution email, pauses, and drops it straight into the owner's "Needs Decision" queue.
  • Ironclad Guardrails:
    • Invoices above the custom threshold (e.g., $10,000+) never auto-send—they always queue for human sign-off.
    • If a client raises a dispute or requests extended terms, all automation freezes instantly.
    • A strict 72-hour contact window prevents duplicate outreach.
    • Every single classification, skip, and send is logged to an immutable audit trail before any external action executes.

The owner spends less than 30 seconds reviewing drafted decisions over morning coffee, clicks approve, and moves on with their day.

How we built it

We designed Chazer as a resilient polyglot system built on top of event-driven infrastructure:

  • The Core Brain: Python agent built with the Strands Agents SDK, registering 4 distinct tools (classify_invoice, draft_email, send_email, write_audit_log). It pairs with Gemini Flash via LiteLLM to generate context-calibrated email copy for fractions of a cent per draft.
  • Autonomous Scheduling & Orchestration: A daily pg_cron sweep on Supabase triggers edge functions that evaluate aging receivables against our domain rules engine and safely dispatch tasks.
  • Data & Transaction Safety: Hosted Supabase PostgreSQL utilizing database views (v_invoices_enriched), row-level locks (FOR UPDATE SKIP LOCKED) to eliminate race conditions, and complete audit logging.
  • Delivery & Communication: Resend API with client-side idempotency keys for verified single-delivery email dispatch.
  • Mission Control Dashboard: A Next.js 14 + Tailwind CSS frontend featuring a 4-stage pipeline visualizer, live aging receivables tables, and a zero-friction decision queue with instant approve/reject actions.

Challenges we ran into

  • The "Incoherent Sequence" Trap: What happens if an invoice is 14 days overdue, but an email failed earlier so the contact count is 0? Jumping straight into a stern "Second Notice" tone sounds robotic and breaks trust. We had to build strict stateful invariants (effective_tier logic) so the agent always meets the client where the actual relationship history stands.
  • Taming Automated Outbound Risk: In financial communications, a single hallucinated demand sent to an enterprise CFO can terminate an account. We solved this by enforcing non-negotiable system invariants: Tier 3 emails, high-value amounts, and active negotiations are architecturally blocked from auto-sending without explicit human approval.
  • Idempotency Across Edge Sweeps: Preventing accidental double-sends when cron jobs retry or manual sweep triggers overlap required locking mechanisms and deterministic 72-hour contact window guards at the database level.

Accomplishments that we're proud of

  • The "Human-in-the-Loop" Sweet Spot: We didn't build an unpredictable chatbot. We built an autonomous system that takes 85% of routine follow-up off your plate and presents the critical 15% to you with a ready-to-send draft.
  • 95% Reduction in Collections Overhead: Turning hours of manual tracking, drafting, and second-guessing into a clean 15-second approval action.
  • Auditable Transparency: Every classification step, tone decision, and send status is logged with structured reasoning, giving creators complete peace of mind that their client relationships are protected.

What we learned

  • Decision surfaces beat chat windows: Users running real businesses don't want to chat with an assistant all day to chase money. They want background autonomy that surfaces clean, binary decisions only when human judgment is indispensable.
  • Tone calibration is the real product: The difference between getting paid promptly and losing a client isn't the reminder itself—it’s the nuance, timing, and professional empathy baked into the copy.
  • Deterministic guardrails create trust: Grounding autonomous loops with strict database-level constraints is what transforms an experiment into software people actually trust with their livelihood.

What's next for Chazer

  • Inbound Reply Intent & Sentiment Analysis: Ingesting inbound client responses (e.g., "We run AP on the 15th" vs. "Can we split this into two milestones?") to automatically categorize intent and generate recommended negotiation workflows.
  • Direct 2-Way Accounting Sync: Seamless plug-and-play integrations with QuickBooks Online, Xero, Stripe Invoicing, and FreshBooks.
  • Dynamic Payment Plan Generation: Empowering the agent to offer pre-approved split-payment links when a client indicates a short-term cash crunch.
  • Multi-Channel Touchpoints: Adding optional SMS and WhatsApp touchpoints for time-sensitive, high-trust B2B communication.

Built With

  • apache-2.0
  • css:
  • license:
  • next.js:
  • python:
  • strandssdk
  • tailwind
  • typescript:
Share this project:

Updates

Submission history