ClientPulse: Freelancer Invoice Risk Forecaster Powered by TabPFN-3.5

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

ClientPulse is a micro-SaaS risk assessment utility built for freelancers, solo contractors, and boutique agencies to eliminate unpaid invoices and delayed cash flows.

Freelancers lose thousands of dollars each year because they lack structured financial risk analysis. Determining whether a prospective or existing client is likely to default or delay payment often relies on pure guesswork.

ClientPulse addresses this directly:

It analyzes tabular patterns across deal size, payment terms, historical late records, and engagement duration.
It generates a probabilistic default risk score using the TabPFN-3.5 foundation model.
It prescribes defensive business measures—such as demanding a 50% upfront milestone deposit, shortening terms, or adding enforceable late fee clauses.

This is a focused utility that freelancers and small agency owners would readily pay a small monthly subscription to use before onboarding high-ticket contracts.

Demo

Code

import os
import pandas as pd
import gradio as gr
from tabpfn_client import TabPFNClassifier

# 1. Prior Labs API Authentication
# Set your token via environment variables or replace with your key
os.environ["TABPFN_TOKEN"] = os.getenv("TABPFN_TOKEN", "YOUR_PRIOR_LABS_API_KEY")

# 2. Historical Freelancer Billing & Payment Data
train_df = pd.DataFrame({
    'amount': [500, 1200, 3200, 450, 8500, 2400, 650, 4800, 1500, 6200, 900, 3100],
    'terms_days': [15, 30, 30, 15, 60, 30, 15, 45, 30, 60, 15, 30],
    'past_late_count': [0, 1, 3, 0, 4, 1, 0, 3, 0, 3, 0, 2],
    'project_weeks': [1, 2, 6, 1, 12, 4, 1, 8, 3, 10, 2, 5],
    'overdue_risk': [0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1]
})

X_train = train_df[['amount', 'terms_days', 'past_late_count', 'project_weeks']]
y_train = train_df['overdue_risk']

# 3. Fit TabPFN-3.5 Foundation Model
classifier = TabPFNClassifier()
classifier.fit(X_train, y_train)

def predict_payment_risk(amount, terms, past_late, weeks):
    query_df = pd.DataFrame([{
        'amount': float(amount),
        'terms_days': int(terms),
        'past_late_count': int(past_late),
        'project_weeks': int(weeks)
    }])

    # Run in-context inference
    probs = classifier.predict_proba(query_df)[0]
    risk_score = round(probs[1] * 100, 1)

    if risk_score > 60:
        verdict = f" HIGH RISK ({risk_score}% probability of late payment)"
        guidance = (
            "**Recommended Action for Freelancers:**\n"
            "- Require a 50% upfront milestone deposit before starting work.\n"
            "- Set automated reminders at 7 days and 2 days before the due date.\n"
            "- Include an explicit late payment interest fee clause in the contract."
        )
    elif risk_score > 30:
        verdict = f" MODERATE RISK ({risk_score}% probability of late payment)"
        guidance = (
            "**Recommended Action for Freelancers:**\n"
            "- Split the project into two distinct milestones.\n"
            "- Confirm billing department contact and payment method in advance."
        )
    else:
        verdict = f" LOW RISK ({risk_score}% probability of late payment)"
        guidance = (
            "**Recommended Action for Freelancers:**\n"
            "- Safe to issue standard NET 15/30 invoice upon milestone completion."
        )

    return f"### Invoice Risk Assessment\n**Status:** {verdict}\n\n{guidance}"

# 4. Gradio UI
with gr.Blocks(theme=gr.themes.Soft(), title="ClientPulse") as demo:
    gr.Markdown("#  ClientPulse: Invoice Payment Risk Forecaster")
    gr.Markdown(
        "A micro-SaaS tool for freelancers: Predict invoice delay and default risk "
        "from past client payment trends using **Prior Labs' TabPFN-3.5** tabular foundation model."
    )

    with gr.Row():
        amount_input = gr.Number(label="Invoice Amount ($)", value=2500)
        terms_input = gr.Dropdown(choices=[15, 30, 45, 60], value=30, label="Payment Terms (Days)")

    with gr.Row():
        late_input = gr.Slider(minimum=0, maximum=10, value=2, step=1, label="Client's Past Late Invoices Count")
        weeks_input = gr.Slider(minimum=1, maximum=16, value=4, step=1, label="Project Duration (Weeks)")

    btn = gr.Button("Evaluate Invoice Risk", variant="primary")
    output = gr.Markdown()

    btn.click(
        fn=predict_payment_risk,
        inputs=[amount_input, terms_input, late_input, weeks_input],
        outputs=output
    )

demo.launch(share=True)

How I Built It

ClientPulse integrates Prior Labs' TabPFN-3.5 (tabpfn-client) foundation model with a Gradio interface:

Foundation Model for Tabular Data: Unlike traditional tree models (GBDTs or Random Forests) that require extensive hyperparameter tuning and hundreds of rows of training records, TabPFN performs in-context learning directly on small sample tables in under a second.
Probabilistic Risk Calibration: Instead of returning a crude binary label, TabPFN yields calibrated Bayesian probability distributions (predict_proba), allowing the agent to dynamically set risk tiers (Low, Moderate, High).
Zero Heavy Infrastructure Overhead: Leveraging managed compute via tabpfn-client eliminates the need for expensive, dedicated GPU hosting, allowing micro-SaaS projects to stay cost-effective.

Why Does Open Innovation Matter?

Financial Privacy: Small business and freelancer billing records represent sensitive client financial data. Foundation models that can run locally or via dedicated private endpoints safeguard this proprietary data from closed platforms.
Accessible Micro-SaaS Economics: Solo founders and freelancers cannot afford thousand-dollar training pipelines or costly proprietary predictive APIs. TabPFN-3.5 democratizes state-of-the-art tabular intelligence with zero training setup costs.
No Vendor Lock-in: The underlying scikit-learn compatible API allows seamless model swapping and self-hosting as the business scales.