DEV Community: Dipendu Ray

Second Ring: A Local-First AI Front Desk for Solo Trades (Hacktoberfest Week 2)

Dipendu Ray — Wed, 14 Oct 2026 14:50:53 +0000

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

What I Built

Solo tradespeople—plumbers, electricians, mobile mechanics, tutors, and cleaners—lose business every single week for one simple reason: they miss inquiries while their hands are full on a job.

When someone has a burst pipe or a leaking tap, they text or DM. If they don't get a prompt response, they move down the list and hire someone else. But solo operators cannot answer calls or compose text messages while fixing a boiler or balancing on a ladder.

Existing automated front desks and AI receptionists are built around metered, per-message proprietary APIs (like OpenAI or Retell) or complex hosted SaaS tools. For an independent contractor, this creates two non-starters:

Metered costs eat their margins on high-volume, low-margin inquiries.
Customer privacy is compromised: job inquiries contain sensitive personal data—names, physical home addresses, access codes, and details about home vulnerabilities.

I built Second Ring (Side Hustle): a local-first, zero-dependency AI front desk that runs entirely in the terminal powered by open-weight models (Gemma 3:4B via Ollama) and deterministic code guardrails.

The local open-weight model extracts and classifies job requests. Pure deterministic code validates required fields, enforces strict safety boundaries (no prices quoted over SMS, no confirmed bookings without owner approval), and stages the job. The trade owner reviews, approves, or dismisses all jobs with simple slash commands right from their terminal.

Who Would Pay For It

Target Audience: Solo service contractors and independent trades (plumbers, electricians, locksmiths, mobile detailers, barbers, private tutors).

Why They Would Pay:

Immediate ROI (Prevented Lost Leads): A single plumbing job won from a fast, professional response easily pays $150–$500+. Missing 2–3 leads a month due to unanswered messages costs thousands of dollars a year.
Zero Ongoing API Billing: Unlike commercial SaaS receptionists charging $50–$100/month plus per-minute or per-token usage fees, Second Ring runs locally on their own laptop with $0 inference cost. A one-time purchase or modest setup fee ($49–$99) gives them an always-on front desk that never meters their messages.
Uncompromised Customer Trust & Privacy: Customers often share sensitive entry details (e.g. "key is under the mat at 14 Elm St"). Independent contractors with privacy-conscious clientele can guarantee client data never touches third-party cloud servers.
Strict Human-in-the-Loop Control: Solo operators fear hallucinations: an AI promising a $50 quote for a complex job or booking a customer when the plumber is already booked solid. Second Ring guarantees that no booking is confirmed and no price is ever quoted without human sign-off.

Demo

Here is a walkthrough of the terminal interaction:

[caller] hi it's Sam at 3 Pine St, my kitchen drain is blocked, can you come Tuesday morning?

[owner] New job for Riverbend Plumbing
[owner] caller - blocked drains
[owner] Sam, 3 Pine St
[owner] Wants: Tuesday morning
[owner] Job #1 — /approve 1 to confirm.

<- Thanks, we've got your details and passed them to Sam. You'll hear back shortly to lock in a time.

The owner can inspect jobs or approve bookings with terminal commands:

/jobs
/approve 1

When approved, the confirmed message is printed for the caller:

-> [SMS to caller] Your booking for Tuesday morning is confirmed with Sam (Riverbend Plumbing). See you then!

Reproducing via Pipe / Quick Test:

# Clone the repository
git clone https://github.com/blezecon/idk.git side-hustle
cd side-hustle

# Pull & run Gemma 3 local model
ollama pull gemma3:4b
ollama serve

# Pipe sample conversation and commands:
printf '%s\n' "my drain is blocked, Sam, 3 Pine St, Tuesday morning" "/jobs" "/approve 1" | npm start

Code

blezecon / idk

Side Hustle — a local-first AI front desk

Job triage for a one-person trade, running entirely in the terminal on open-weight models you host yourself.

A plumber, barber or tutor misses a call while their hands are full, and the enquiry arrives as a text, a DM or a form message. Paste it into the front desk and a local open-weight model works out what the job is and collects the few details the owner actually needs. The owner reviews every job in the same terminal and approves it Nothing is promised to a customer until a human says so.

Built for the Hacktoberfest Open-Source AI Challenge: Week 2 — Side Hustle.

Why open models matter here

The existing tools in this space glue a closed, per-message API (OpenAI, Retell) to the front desk. That's a bad fit for a one-person business:

Cost. A busy trade can send…

View on GitHub

Repository: https://github.com/blezecon/idk
License: MIT
Dependencies: Zero external npm packages (package.json has 0 dependencies). Runs on native Node.js 22.5+ with built-in SQLite (node:sqlite), built-in test runner (node:test), and native fetch.

How I Built It

Architecture Overview

The system strictly decouples language extraction from decision authority:

flowchart LR
  C[Caller Message] -->|Input| A[Terminal Front Desk]
  A -->|Prompt + JSON Schema| M[(Ollama / Gemma 3 Local)]
  M -->|Structured JSON| V{Deterministic Guardrails}
  V -->|Missing required field| C
  V -->|Complete + Verified| DB[(SQLite Jobs DB)]
  DB --> O[Trade Owner CLI]
  O -->|/approve ID| C
  V -->|Spam / Emergency / Needs Human| O

1. Model Layer (`src/model.js`)

Runs Gemma 3:4B via Ollama's local HTTP API (/api/chat).
Uses structured output schema (format: SCHEMA) to force strict JSON containing:
- intent: "quote" | "booking" | "question" | "emergency" | "spam" | "wrong_number" | "human"
- service, urgency, name, address, preferred_time
- needs_human: boolean flag
- reply_text: single polite question asking for the next missing piece of info
Includes automatic retry handling for model stability.

2. Deterministic Guardrails (`src/triage.js`)

An LLM should never be trusted with money, calendar commitments, or safety policies. The deterministic layer enforces:

Price Protection: Regex inspection prevents any dollar, euro, pound, or hourly rate from ever reaching the customer. Quotes must be given on-site.
No False Commitments: Any phrasing resembling "you're booked" or "confirmed for" generated by a model is discarded. Only the owner can issue a confirmation via /approve.
Handoff Rules: Any emergency, abusive interaction, or conversation exceeding the turn cap immediately transitions to needs_human handoff.
Ordered Field Collection: Checks required fields in order (service, name, address, preferred_time) so the customer is asked only one clear question at a time.

3. Local Persistence (`src/db.js`)

Uses Node.js native node:sqlite (DatabaseSync) with WAL mode enabled.
Stores conversations, individual turns, and active jobs locally in second-ring.db.

Why Does Open Innovation Matter?

Open-source AI and open-weight models are the catalyst that makes this entire business viable:

Zero-Marginal-Cost Inference: Closed APIs charge per token. A single active trade handling hundreds of inquiries a month faces unpredictable operational bills. Open-weight models like Gemma run locally with zero API expenses, turning an unpredictable operational liability into predictable software.
True Data Sovereignty & Privacy: Job inquiries for home services inherently expose physical addresses, home vulnerabilities ("back door lock broken"), and schedules ("we are away until Friday"). Routing this information through third-party proprietary clouds creates unnecessary liability. Open-weight inference ensures data stays 100% on the owner's hardware.
Vendor Independence: When building a tool for independent small businesses, relying on a closed provider leaves you vulnerable to sudden pricing changes, rate limits, or discontinued model checkpoints. Open-weight models allow you to lock in working weights and swap models (Gemma, Llama, Qwen) whenever you choose.
Offline Capability: Trades often operate in areas with poor cellular reception (basements, construction sites, rural properties). A local-first stack running on a laptop or local mini-server continues functioning without reliable cloud connectivity.

Built with ❤️ for solo trades and small business owners during Hacktoberfest 2026 Week 2.

DevOrbit Grounded Resume & Job Matching Built for Friends Seeking Work

Dipendu Ray — Sat, 03 Oct 2026 15:16:12 +0000

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

What I Built

Applying for jobs today feels like screaming into a void. You send a resume out, hear nothing back, and never find out whether you were rejected for a missing skill or because a recruiter simply moved on. Job listings are walls of buzzwords. Resumes are walls of bullet points. To make things worse, generic AI resume tools paper over this with an arbitrary number—"72% match"—and then proceed to hallucinate skills or experience you don't even have.

I built DevOrbit for my friends who are actively seeking jobs.

When you're searching for work, what you need isn't flattery or invented qualifications—it's honest clarity:

Where does my background legitimately line up with this job listing?
What requirements do I satisfy, what is partial, and what is genuinely missing?
How can I highlight my real experience without making anything up?

DevOrbit is a privacy-first, grounded job matching web app. It takes a candidate's PDF resume, extracts their profile using an open-weight model, searches across six real-time job boards simultaneously, and runs a deterministic matching engine in plain code to produce an honest breakdown of where you stand. Every single recommendation is strictly grounded in what you actually wrote.

Demo

Check out the project repository on GitHub:

GitHub Repository: https://github.com/blezecon/devorbit

How to Run Locally

You can spin up DevOrbit in minutes with local inference via Ollama or via OpenRouter:

# 1. Clone & install
git clone https://github.com/blezecon/devorbit.git
cd devorbit
npm install #pnpm i

# 2. Setup environment
cp .env.example .env.local

# Run completely local with Gemma (Ollama)
ollama pull gemma3:4b
ollama serve

# You Can run this with llama cpp also
# If you are facing problems with local models, then You can use openrouter api also

# 3. Start DevOrbit
npm run dev #pnpm dev

Visit http://localhost:3000 to upload a resume and explore matched jobs.

Code

blezecon / devorbit

Fully Vibe Coded

DevOrbit

Understand which jobs actually fit your resume.

Built for the Hacktoberfest 2026 Weekend Challenge: Build for a Friend — an MVP that helps one real person compare their resume against real job listings, with an open-weight model doing the reading.

Problem

Applying to jobs feels like guessing. You send a resume, hear nothing back, and never learn whether you were rejected for a skill you lacked or because the recruiter moved on. Job descriptions are walls of text. Your resume is a different wall of text. Nothing in either tells you where they line up.

Generic AI resume tools paper over this with a single invented score — "72% match" — and then suggest you add experience you do not have.

Solution

DevOrbit reads both documents with an open-weight model, puts them in the same structured vocabulary, and then compares them with plain code:

Matches — requirements your resume…

View on GitHub

The codebase is open source under the permissive MIT License.

Frontend / Framework: Next.js 16 (App Router), React 19, TypeScript, Tailwind CSS v4.
UI Components: Neobrutalism UI built on Base UI / shadcn registry with Lucide icons.
Validation: Zod runtime schema validation on all inputs and model outputs.
PDF Extraction: unpdf for zero-disk, pure in-memory text parsing.
Test Suite: Vitest suite covering matching logic, job providers, and parsing.

How I Built It

The core philosophy behind DevOrbit is separation of language extraction from evaluation logic. Large language models are fantastic parsers, but notoriously unreliable judges if left unconstrained.

DevOrbit implements a 5-stage pipeline:

flowchart TD
    A["1. PDF Upload (In-memory via unpdf)"] --> B["2. Candidate Extraction (Gemma Open-Weight Model)"]
    C["Job Search (6 Free APIs: Himalayas, Jobicy, RemoteOK, Remotive, Arbeitnow, Ocean of Jobs)"] --> D["3. Requirements Extraction (Gemma Open-Weight Model)"]
    B --> E["4. Deterministic Matching Engine (Plain Code - Zero LLM Hallucinations)"]
    D --> E
    E --> F["5. Grounded Explanation & Suggestions (Gemma Model + strict evidenceRef)"]

The 5 Stages:

Extract: The PDF is parsed directly in memory with unpdf without writing any temp files to disk.
Candidate Extraction: An open-weight model parses messy resume text into structured Candidate JSON (skills, experience, projects, education).
Job Requirements Extraction: When a job is selected from one of the 6 integrated job boards, the model extracts core requirements into structured JobRequirements JSON.
Deterministic Match (Plain Code): No model is involved here. The matching is pure arithmetic and normalized token matching with an alias table. The same resume and job will always produce the identical fit score. A model cannot talk itself into an inflated percentage.
Grounded Explanation: The model explains matches and highlights suggestions. Every single suggestion must quote an exact phrase (evidenceRef) from your resume. If it references an ungrounded or invented detail, the suggestion is discarded in code.

Why Does Open Innovation Matter?

Open-source AI is not an afterthought in DevOrbit—it is the foundational reason the product can be trusted:

Absolute Resume Privacy: A resume contains deeply sensitive personal information—full legal names, employment timelines, educational history, and contact details. Sending this data to closed proprietary cloud APIs exposes job seekers to tracking, logging, and data harvesting. With open-weight models (running locally on Ollama or llama.cpp), the resume never leaves your machine.
Zero Barrier to Entry (Zero API Cost): Job seekers are often on strict budgets. Running an open-weight 4B model locally costs nothing in API subscriptions or token billing.
Auditability & Integrity: Commercial ATS scanners hide their algorithms behind proprietary black boxes. With open-source models and transparent prompts versioned directly in code (PROMPT_VERSION), every evaluation is fully auditable.
Resilience: The system supports standard OpenAI-compatible endpoints, allowing users to swap between local runtimes (Ollama, llama-server) or hosted gateways (OpenRouter) with zero code modifications.

Built with ❤️ for friends on the job hunt during the Hacktoberfest 2026 Weekend Challenge.

DEV Community: Dipendu Ray

Second Ring: A Local-First AI Front Desk for Solo Trades (Hacktoberfest Week 2)

What I Built

Who Would Pay For It

Why They Would Pay:

Demo

Reproducing via Pipe / Quick Test:

Code

blezecon / idk

Side Hustle — a local-first AI front desk

Why open models matter here

How I Built It

Architecture Overview

1. Model Layer (src/model.js)

2. Deterministic Guardrails (src/triage.js)

3. Local Persistence (src/db.js)

Why Does Open Innovation Matter?

DevOrbit Grounded Resume & Job Matching Built for Friends Seeking Work

What I Built

Demo

How to Run Locally

Code

blezecon / devorbit

Fully Vibe Coded

DevOrbit

Problem

Solution

How I Built It

The 5 Stages:

Why Does Open Innovation Matter?

1. Model Layer (`src/model.js`)

2. Deterministic Guardrails (`src/triage.js`)

3. Local Persistence (`src/db.js`)