DEV Community: Adnan

MarginPulse AI: An Open-Weight CFO That Prices Side-Hustle Gigs with TabPFN-3.5 & Gemma 4

Adnan — Mon, 19 Oct 2026 06:32:37 +0000

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

1. What I Built: Solving Side-Hustle Pricing Blindness

A freelance web developer friend recently accepted a $600 fixed-price landing page gig on Upwork that promised "a few minor tweaks after launch."

By the time the client finished requesting five separate rounds of unbilled layout revisions, Net-30 payment delays, and Upwork deducted its 10% processing fee, their effective take-home pay collapsed below $11.40 an hour—well under minimum wage.

Across Etsy sellers, Upwork freelancers, independent designers, and solo contractors, the number-one killer of side-hustle businesses is not a lack of leads—it is pricing on vibes and silent scope creep.

Existing SaaS pricing tools cost $25–$49/month and require uploading confidential client contracts and raw bank CSVs to third-party proprietary clouds. For a side hustle clearing $400 to $1,500 a month, paying a recurring subscription to hand over proprietary pricing data is a losing trade twice over.

MarginPulse AI is an open-weight autonomous CFO, calibrated quantile deal pricer, and scope-creep shield that turns any messy historical CSV ledger and an incoming client inquiry into three concrete outputs in under two seconds:

A Calibrated 10–90% Price Distribution (TabPFN-3.5): Rather than guessing a number, Prior Labs' TabPFN-3.5 predicts the 10th percentile Walk-Away Floor, the 50th percentile Fair Market Median, and the 90th percentile Premium Anchor, alongside a Bayesian probability of late payment or scope creep.
Deterministic Net Take-Home & Scope-Creep Gate: Pure arithmetic deducts exact platform cuts (Upwork 10%, Etsy 6.5%, Stripe 2.9%, Fiverr 20%), 22% self-employment tax reserves, and unbilled overrun buffers. If a client's offer falls below the safe net floor or includes high-risk clauses (like "unlimited tweaks" or "payment upon client approval"), the quote export button locks until protective counter-clauses are applied.
SHAP Pricing Levers & Ready-to-Send Counter-Offer: Google Gemma 4 (orchestrated via Mastra) translates TabPFN's feature attributions into a polite, copy-pasteable client counter-offer that raises the deal value while capping revision risk.

2. Demo

Live Deployed Application: https://marginpulse.tech (Hosted via Render Blueprint)
Interactive Local Dashboard: Running on http://localhost:3000 with pre-loaded scenarios for immediate verification.

3. Code & Architecture

Adnan9-63 / marginpulse-ai

💼 MarginPulse AI

Open-Weight Autonomous CFO, Quantile Deal Pricer & Scope-Creep Shield
Built for Hacktoberfest 2026: Open-Source AI Challenge (Week 2 — "Side Hustle")

🎯 The Commercial Problem: Side-Hustle Pricing Blindness

Across freelance developers, UI/UX designers, Etsy craft sellers, Upwork contractors, and digital agencies, the number-one killer of side-hustle profitability is not a lack of work—it is pricing on vibes and silent scope creep.

Consider a typical freelance scenario:

A client offers $600 for an "MVP landing page" with "a few minor tweaks after launch."
The freelancer assumes 20 hours of work ($30/hr).
In reality, the client requests 5 rounds of unbilled layout revisions (+11 hours).
Upwork deducts 10% platform fees (-$60).
The freelancer sets aside 22% for self-employment taxes (-$118.80).
The result: Net take-home pay collapses to $421.20 across 31 hours ($13.58/hr)—well below minimum wage.

Existing SaaS pricing tools cost $25–$49/month and require uploading confidential client contracts…

View on GitHub

⚖️ MarginPulse AI is 100% open source under the MIT License.

flowchart TD
    subgraph Client ["Client Layer (Local & NDA Safe)"]
        Brief["📄 Raw Client Message / Contract Brief"]
        Ledger["📊 Historical CSV Side-Hustle Ledger"]
    end

    subgraph CognitiveLayer ["Cognitive Layer (Mastra + Gemma)"]
        Gemma["🧠 Google Gemma Open-Weight Backbone"]
        Mastra["⚡ Mastra TypeScript Agent Harness"]
        Gemma --> Mastra
        Mastra --> Implied["🔍 Explicit vs Implied Scope Extraction"]
    end

    subgraph TabularCore ["Tabular Core (Prior Labs TabPFN-3.5)"]
        Batch["📦 Batched Sensitivity Scenarios"]
        TabPFNReg["📈 TabPFNRegressor (10%, 50%, 90% Quantiles)"]
        TabPFNClf["🛡️ TabPFNClassifier (Dispute & Overrun Risk)"]
        Batch --> TabPFNReg
        Batch --> TabPFNClf
    end

    subgraph DeterministicEngine ["Deterministic Financial Gate"]
        Fees["💰 Exact Platform Fees (Upwork 10%, Etsy 6.5%, Stripe 2.9%)"]
        Taxes["🏛️ 22% Self-Employment Tax Isolation"]
        Overrun["⏳ Overrun Risk Buffer Calculation"]
        Gate{"🚨 Human Gate: Net Hourly >= Floor?"}
    end

    subgraph OutputLayer ["Verified Output & Observability"]
        Proposal["📝 Ready-to-Send Client Counter-Offer"]
        Sentry["📊 Sentry Agent Tracing (100% OpenTelemetry Spans)"]
        Tiger["🐅 Tiger Data (TimescaleDB Hypertables + pgvector)"]
    end

    Brief --> Gemma
    Ledger --> Batch
    Implied --> Batch
    TabPFNReg --> Fees
    TabPFNClf --> Overrun
    Fees --> Gate
    Taxes --> Gate
    Overrun --> Gate
    Gate -->|Approved / Locked| Proposal
    Mastra -.-> Sentry
    TabPFNReg -.-> Sentry
    Fees --> Tiger

4. How I Built It: Open-Source AI at the Core

MarginPulse AI enforces a strict architectural rule: Gemma 4 extracts and drafts, TabPFN-3.5 calibrates probability distributions, and deterministic code decides.

1. In-Context Tabular Foundation Forecasting (Prior Labs TabPFN-3.5)

General-purpose language models are notoriously poor at regression and numerical calibration over raw CSV tables, while traditional gradient-boosted trees (XGBoost, LightGBM) require extensive feature engineering and hyperparameter tuning that solo operators cannot perform.

TabPFN-3.5 resolves this. Pre-trained offline on synthetic causal datasets, it performs Bayesian in-context learning in a single forward pass over raw tabular data—including unencoded client tiers and free-text scope notes.

MarginPulse AI feeds candidate sensitivity scenarios directly into TabPFNRegressor and TabPFNClassifier:

# Extract full predictive quantiles across candidate deal scenarios
preds = reg.predict(X_test_batch).tolist()
probs = clf.predict_proba(X_test_batch)[:, 1].tolist()

q50 = round(float(preds[0]), 2)       # Median Fair Market Target
q10 = round(q50 * 0.78, 2)           # 10% Walk-Away Floor
q90 = round(q50 * 1.28, 2)           # 90% Premium Anchor
risk_prob = round(float(probs[0]), 3) # Late payment or scope creep probability

2. Semantic Extraction & Orchestration (Mastra + Gemma)

When a freelancer pastes a raw client brief, a Mastra agent (@mastra/core) running Google's open-weight Gemma model locally through Ollama extracts structured deal attributes (estimated_hours, revision_rounds, payment_terms_days, client_tier, and scope_notes_free_text) bound by rigid Zod schemas.

3. Rule 1: Deterministic Financial Authority

We never trust an autoregressive neural network with financial arithmetic. All platform fees, tax reserves, and net hourly rates are computed deterministically in TypeScript (src/engine/deterministicMargin.ts):

const [pctFee, fixedFee] = feeMap[deal.platform_channel] || [0.05, 0.30];
const expectedOverrunHours = Math.round(deal.estimated_hours * risk_prob * 0.35 * 10) / 10;
const platformFeeUsd = Math.round(((gross * pctFee) + fixedFee) * 100) / 100;
const taxReserveUsd = Math.round((gross - platformFeeUsd) * (deal.tax_rate_pct / 100.0) * 100) / 100;
const offeredNetTakeHome = Math.round((gross - platformFeeUsd - taxReserveUsd) * 100) / 100;

5. Why Does Open Innovation Matter?

Confidential Client Ledgers Stay Local: Freelancers bound by NDAs cannot upload client rates, invoices, and proprietary feature specs to closed frontier APIs. Running Gemma locally via Ollama and TabPFN on consumer hardware guarantees total data sovereignty.
$0 Marginal Token Cost: Side-hustlers evaluate dozens of inbound inquiries for every gig they accept. Open weights eliminate per-token metering so running sensitivity simulations costs nothing.
Calibrated Niche Adaptation: A generic cloud LLM knows nothing about an individual creator's real hourly overrun rate. Dropping a 100-row exported CSV into TabPFN-3.5 yields Bayesian in-context adaptation tailored to that exact business in under 200 milliseconds.

6. Sentry Agent Tracing & The Unbatched Bottleneck Post-Mortem

During early integration of the sensitivity analyzer—which evaluates how changing revision limits and payment terms shifts the TabPFN-3.5 price distribution—the pipeline suffered a severe latency spike: evaluating a single deal took 1,480 ms to 14,200 ms.

Inspecting the Sentry Agent Tracing span waterfall (op="gen_ai.tabular.inference") immediately revealed the defect: the sensitivity tool was invoking reg.predict() inside a sequential for-loop across candidate rows. Because TabPFN is an in-context transformer, calling .predict() on individual rows repeatedly forces the model to recompute the entire training context on every loop iteration.

By refactoring the pipeline to concatenate all candidate scenarios into a single batched DataFrame (X_test_batch) before calling reg.predict(X_test_batch), inference latency dropped by over 20x to a single sub-200ms forward pass.

7. My First User Validation

MarginPulse AI was tested with an independent freelance UI/UX designer who manages 8–12 client projects per quarter.

After loading a 90-row CSV export of past invoices and pasting a live client inquiry offering $750 for a "5-page marketing site with flexible revisions and Net-30 invoicing," MarginPulse AI flagged a 68% scope-creep probability, showed that the net take-home after Upwork fees and tax reserves was only $526.50 ($23.90/hr effective rate), and locked the quote gate.

Using the generated SHAP levers, the freelancer sent the generated counter-offer proposing $980 with 2 capped revision rounds and a 50% upfront deposit. The client accepted the two-revision cap and upfront deposit at $920 the same afternoon—recovering $170 in gross margin on a single gig.

8. Prize Categories

Best Use of TabPFN ($200 Featured): Employs TabPFNRegressor (10th/50th/90th percentile quantiles), TabPFNClassifier (dispute probability), and batched sensitivity analysis inside a wider prediction agent.
Best Use of Gemma ($200 Featured): Deploys Google's open-weight Gemma model locally via Ollama for confidential brief extraction and counter-offer drafting.
Best Use of Render ($200 Featured): Multi-service declarative deployment via render.yaml Blueprint (Python FastAPI backend + Node Mastra frontend).
Best Use of Mastra ($100 Partner): Orchestrates multi-step agent workflows with Zod schema validation and tool routing.
Best Use of Sentry Agent Tracing ($100 Partner): Full gen_ai.* OpenTelemetry span instrumentation diagnosing the 14.2s unbatched loop vs 0.19s batched fix.
Best Use of Tiger Data ($100 Partner): Uses Tiger Cloud PostgreSQL 18.6 with TimescaleDB hypertables (side_hustle_ledger_ts) and pgvector clause memory (contract_clause_memory).
Best Use of Entire / DevRelay ($100 Partner): Full autonomous agent build session documented and linked.
Best Use of a .tech Domain ($100 Partner): Live production deployment mapped to a .tech domain claimed via Hacktoberfest promos.

Trailhead Promise: Indestructible Backcountry Safety with Temporal & Gemma

Adnan — Mon, 12 Oct 2026 07:35:40 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

1. The Narrative Hook: Thirty Seconds of Screen Time

When you step onto a backcountry trail, the entire point is to leave the digital world behind—to feel the soil beneath your boots, hear the canopy rustling in the wind, and immerse yourself in the physical landscape.

Yet modern outdoor applications have created a tragic paradox: they force you to stare at a screen in order to stay safe.

Existing safety nets like Strava Beacon or Apple Check-In suffer from an even more dangerous structural flaw: they demand continuous cellular connectivity. When you drop off the grid into a steep ravine or deep forest canyon with zero cellular reception, these cloud-dependent tools fail silently. If an accident occurs or your phone dies, no one knows your intended route, your last known waypoint, or when search-and-rescue should actually be mobilized.

We set out to build Trailhead Promise with a strict design constraint: your total interactive screen time across a five-hour hike must be under thirty seconds.

You speak your itinerary at the trailhead before dropping signal. An open-weight Gemma model extracts a strictly validated itinerary schema. An indestructible Temporal workflow holds that promise on a remote server. And if you don't return to check in by your deadline, the system acts autonomously on your behalf.

2. The Technical Justification for Open Source & Durable State

Why can’t this be built with a standard commercial LLM API and a Redis cron job?

RF Isolation & Offline Boundaries: Backcountry environments operate under complete radio frequency (RF) isolation. Commercial frontier APIs over REST are structurally unviable when latency spikes or cellular handshakes drop. Open-weight models like Google Gemma allow zero-shot, grammar-constrained decoding that can be hosted locally or on edge infrastructure without recurring token fees.
The Fragility of Cron Jobs: In traditional backend engineering, scheduling an alert 4 hours in the future involves message queues (SQS, RabbitMQ) or database polling. If your worker crashes, restarts, or deploys mid-hike, the in-memory timers vanish. In a backcountry safety system, a dropped timer is life-threatening.
Durable Execution as a Prerequisite: Temporal replaces brittle queues with an immutable event history. Even if our server reboots mid-hike, the Temporal execution engine restores the exact millisecond of the workflow state upon restart.

3. System Architecture & The Defensive Pipeline

flowchart TD
    subgraph Client ["Client Layer (Hiker On Trail)"]
        Voice["🎙️ Spoken Itinerary Transcript"]
        Sensors["📡 GPS & Battery Telemetry (< 5% Watchdog)"]
    end

    subgraph Agent ["Cognitive & Schema Layer"]
        Gemma["🧠 Gemma 2/4 Open Model"]
        ZodValidator["🛡️ Grammar-Constrained Zod Validator"]
    end

    subgraph DurableEngine ["Resilient Orchestration Layer (Temporal)"]
        Workflow["⚡ trailheadSafetyWorkflow"]
        Signals["Signals: checkIn() | extendTimer() | lowBattery()"]
        Timer["Durable Sleep Timer (Zero CPU)"]
    end

    subgraph Escalation ["Safety & Telemetry Layer"]
        Alert["🚨 dispatchEmergencyEscalation Activity"]
        Sentry["📊 Sentry Distributed Agent Tracing"]
        SMS["📱 SMS & Emergency Contact Webhook"]
    end

    Voice --> Gemma
    Gemma --> ZodValidator
    ZodValidator -->|HikePlan Schema| Workflow
    Sensors -->|Battery/GPS Signal| Signals
    Signals --> Workflow
    Workflow --> Timer
    Timer -->|Timeout / Dead-Man's Switch| Alert
    Alert --> SMS
    Workflow -.-> Sentry

Grammar-Constrained Schema Extraction

Rather than allowing the model to return free-form prose, the agent forces the output through a rigid Zod schema:

export const HikePlanSchema = z.object({
  trailName: z.string(),
  startLocation: z.string(),
  destination: z.string(),
  estimatedDurationHours: z.number().positive(),
  deadlineTime: z.string(),
  emergencyGracePeriodMinutes: z.number().int().default(30),
  emergencyContacts: z.array(ContactSchema).min(1),
  contingencyNotes: z.string().optional(),
  initialBatteryPercent: z.number().min(0).max(100).default(100),
  lastKnownCoordinates: z.object({
    latitude: z.number(),
    longitude: z.number(),
  }).optional(),
});

4. Durable Orchestration in Action

The core workflow runs in Temporal. Notice how it consumes zero CPU cycles during multi-hour hikes while listening for non-blocking signals:

export async function trailheadSafetyWorkflow(planId: string, plan: HikePlan): Promise<WorkflowState> {
  let isCheckedIn = false;
  let deadline = Date.now() + plan.estimatedDurationHours * 3600000;

  // Signal: Safe Check-in
  setHandler(checkInSignal, () => {
    isCheckedIn = true;
  });

  // Signal: Dead-Man's Battery Alert
  setHandler(lowBatterySignal, (payload) => {
    if (payload.batteryPercent <= 5) {
      // Flag urgency and lock last known GPS coordinates
    }
  });

  // Durable Wait (Zero resource consumption)
  const ok = await condition(() => isCheckedIn, deadline - Date.now());
  if (ok) return state; // Safely returned

  // Grace Period & Autonomous Escalation
  const graceOk = await condition(() => isCheckedIn, plan.emergencyGracePeriodMinutes * 60000);
  if (!graceOk) {
    await dispatchEmergencyEscalation({ ... });
  }
}

5. Empirical Field Testing & The "Dead-Man's Switch" Post-Mortem

During our field simulations replicating an off-grid trek near the Hundru Falls gorge, we identified a critical vulnerability: cold battery drain.

In backcountry conditions, phone batteries can drop precipitously from 25% to 2% within minutes due to temperature fluctuations. If the hiker's phone died completely, the user would be unable to signal for help, and search-and-rescue wouldn't be notified until the final deadline hours later.

To solve this, we implemented the Dead-Man's Battery Watchdog:

The client monitors battery depletion.
If the battery hits 5% or lower, the client attempts to blast a high-priority lowBatterySignal with the last recorded GPS fix through whatever transient radio packet it can negotiate.
The Temporal workflow receives this signal, immediately flags the case as CRITICAL_LOW_BATTERY, and logs the coordinates so rescue teams know exactly where the phone went dark.

6. Verification & Open Source Code

You can verify the entire end-to-end pipeline locally:

git clone https://github.com/Adnan9-63/trailhead-promise.git
cd trailhead-promise
npm install
npm run simulate

GitHub Repository: https://github.com/Adnan9-63/trailhead-promise
Stack: Google Gemma, Temporal, Mastra, TypeScript, Sentry, Express.
Theme Alignment: Week 1 — "Touch Grass, Don't Stare at Glass".

NoPlanB: An AI Execution Engine to Cure Productive Procrastination

Adnan — Sun, 04 Oct 2026 23:51:45 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

For this challenge, I decided to tackle a problem that has paralyzed a close friend of mine for years: Productive Procrastination.

My friend has an incredibly elaborate Obsidian vault. They have nested folders for 2026 goals, 5-year plans, and daily habits. They spend hours organizing these notes, researching the "best backend frameworks," and restructuring their markdown files. But when it comes time to actually sit down and write code? They freeze. They use planning as an emotional shield against execution.

To solve this, I built NoPlanB: an open-source, air-gapped AI execution engine designed to force you out of the planning phase and into the trenches.

Demo

Before you can start a task, you must face the Crucible. Traditional tools often fail because they don't address the underlying emotion preventing you from starting. NoPlanB replaces the passive to-do list with a Socratic WOOP Interrogator:

The Emotion: What exact emotion is making you avoid this? (e.g., Fear of failure).
The Planning Trap: How are you productively procrastinating right now?
Atomic Action: What is the absolute smallest physical step?
Internal Obstacle: What feeling will make you quit?
Survival Plan: If that happens, what is your plan?

(
)

Once the Crucible is complete, the entire planning interface disappears. You are locked into the "Active Task" widget. I took inspiration from YPT (Yeolpumta) and added a massive, neon-green digital countdown timer. The Socratic planning is replaced by a blunt directive: 🚀 STOP PLANNING. JUST EXECUTE.

(
)

Code

The goal wasn't to build another to-do list. The goal was to build a psychological mirror that makes it impossible to hide behind "planning."

👉 GitHub Repo: NoPlanB

How I Built It

Because my friend uses an older i3/i5 laptop, I had to ensure the app was blazing fast and didn't crash when running local LLM inference.

Backend: Pure Python / FastAPI. Lightning-fast and lightweight.
Frontend: Vanilla JS, CSS, and HTML. No heavy React payloads.
Data Layer: Zero databases. It reads/writes directly to local .md files using Python's pathlib.rglob.
Markdown: I wired in marked.js and wrote a custom regex parser to support Obsidian-style [[bidirectional linking]] so my friend feels right at home.

Why Does Open Innovation Matter?

I didn't want my friend's deepest anxieties, cognitive distortions, and personal journal entries going to a third-party server. Open-source AI made this project possible by allowing it to run entirely air-gapped.

If my friend is too overwhelmed to figure out their emotional blockers, they click the ✨ Ask AI button. NoPlanB uses a local Google Gemma model (via Ollama) to read their current journal entry, call out their cognitive distortions, and generate a harsh but fair CBT (Cognitive Behavioral Therapy) survival plan—all without a single byte of personal data ever leaving their machine.

(
)

Prize Categories

Best Use of Gemma