DEV Community: Jay Durango

I Built a 10-Factor Scoring Algorithm to Rate Any Business Location (C to AAA)

Jay Durango — Sun, 08 Mar 2026 06:28:27 +0000

I run a small portfolio of brick-and-mortar businesses. Every time I evaluate a new location — gas station, auto shop, retail space — I'd spend days pulling data from Google Maps, census reports, traffic studies, and competitor lists. Then I'd dump it all into a spreadsheet and try to make a decision.

It was slow, inconsistent, and subjective. So I built an algorithm to do it.

The Problem: Site Selection is Broken

Most small business owners pick locations based on gut feeling, a broker's pitch, or "it felt right when I drove by." The data exists to make better decisions, but it's scattered across dozens of sources and there's no standardized way to score it.

Enterprise players use tools like Placer.ai ($500+/mo) or hire consultants ($5K+ per report). Small operators get nothing.

I wanted something that could score any address on a standardized scale — like a credit score, but for business locations.

The 10-Factor Algorithm

After analyzing what actually correlates with business success at physical locations, I landed on 10 dimensions:

#	Factor	Weight	What It Measures
1	Traffic Volume	15%	Daily vehicle/foot count from DOT + Google Popular Times
2	Demographics	12%	Median income, population density, age distribution
3	Competition Density	12%	Same-category businesses within radius
4	Accessibility	10%	Road type, intersection quality, public transit
5	Visibility	10%	Frontage, signage potential, setback distance
6	Parking & Layout	8%	Lot size, spaces per sqft, flow
7	Anchor Proximity	8%	Distance to Walmart, Target, major chains
8	Growth Trajectory	8%	5-year population trend, permit activity
9	Market Saturation	9%	Revenue-per-capita vs. business count
10	Risk Factors	8%	Crime rate, flood zone, vacancy rate

Total: 100% weighted score.

The Grading System

Raw scores get mapped to letter grades using distribution-based thresholds:

function calculateGrade(score, population) {
  const percentile = getPercentileRank(score, population);

  if (percentile < 40) return { grade: 'NR', label: 'Not Rated' };
  if (percentile < 55) return { grade: 'C', label: "That Ain't It" };
  if (percentile < 70) return { grade: 'B', label: 'Good but not Great' };
  if (percentile < 85) return { grade: 'A', label: 'Pull the Trigger' };
  if (percentile < 95) return { grade: 'A+', label: 'Unicorn' };
  return { grade: 'AAA', label: 'Great White Buffalo' };
}

The labels are intentionally blunt:

C = "That Ain't It" — meets minimum criteria but has significant drawbacks
B = "Good but not Great" — solid fundamentals, notable limitations
A = "Pull the Trigger" — strong across all dimensions
A+ = "Unicorn" — exceptional, rare find
AAA = "Great White Buffalo" — statistical anomaly, once in a lifetime

Self-Improving Thresholds

Here's the part I'm most proud of. The algorithm never stops learning.

Every scored location feeds back into the dataset. As more locations get analyzed, the averages recalibrate, thresholds shift, and grades become more accurate.

async function recalibrateThresholds(env) {
  const allScores = await env.SCORES_DB.list();
  const dataset = allScores.map(s => JSON.parse(s.value));

  // Recalculate population statistics
  const stats = calculateDistribution(dataset);

  // Update grade boundaries based on actual distribution
  await env.THRESHOLDS.put('current', JSON.stringify({
    updated: new Date().toISOString(),
    sample_size: dataset.length,
    mean: stats.mean,
    stddev: stats.stddev,
    percentiles: stats.percentiles,
  }));
}

With 10 scored locations, the grades are rough estimates. With 1,000, they're statistically meaningful. With 10,000, they're approaching ground truth.

Data Sources (All Free or Cheap)

One design constraint: keep data costs near zero.

Source	Data	Cost
US Census API	Demographics, income, population	Free
Google Places API	Competitor count, ratings, categories	$0.032/call
Google Maps Platform	Geocoding, distance matrix	Free tier generous
DOT Traffic Data	AADT counts by road segment	Free (public data)
FEMA Flood Maps	Flood zone classification	Free
FBI UCR	Crime statistics by area	Free
Building Permits API	Construction/growth activity	Free (varies by county)

Total cost per location analysis: roughly $0.15 - $0.30.

Compare that to $500+/mo for Placer.ai or $5K for a consultant report.

The Architecture

The whole thing runs on Cloudflare Workers (serverless, $0/mo hosting):

User enters address
  → Geocode via Google Maps
  → Fan out to 10 data sources in parallel
  → Normalize each factor to 0-100
  → Apply weights
  → Calculate composite score
  → Map to letter grade
  → Store result (feeds back into thresholds)
  → Return report

Processing time: ~3 seconds per address.

Context Matters

A raw score isn't enough. The algorithm factors in context:

Time of year: Seasonal businesses score differently in summer vs. winter
Market conditions: Vacancy rates shift what "good" looks like
Location-specific factors: A gas station at a highway exit is evaluated differently than one in a residential neighborhood
Competition quality: 5 competitors with 2-star reviews is different from 5 with 4.8-star reviews

Real Example

I ran the algorithm on a gas station I was evaluating in suburban Minnesota:

Traffic Volume:    82/100 (28,000 AADT on adjacent road)
Demographics:      74/100 (median income $78K, growing area)
Competition:       61/100 (4 stations within 2 miles)
Accessibility:     88/100 (signalized intersection, easy in/out)
Visibility:        79/100 (corner lot, good frontage)
Parking:           70/100 (adequate but tight)
Anchor Proximity:  85/100 (Walmart 0.3 mi, Target 0.8 mi)
Growth Trajectory: 77/100 (12% population growth in 5yr)
Market Saturation: 58/100 (slightly oversaturated)
Risk Factors:      81/100 (low crime, no flood zone)

Composite Score: 75.4
Grade: A — "Pull the Trigger"

I bought it. It's been profitable since month one.

What I Learned Building This

Weighted scoring beats gut feeling every time. Even rough data, systematically analyzed, outperforms intuition.
The grade scale matters more than the score. Nobody remembers "75.4" but everyone remembers "A — Pull the Trigger."
Self-improving algorithms are worth the extra complexity. The recalibration loop is the difference between a static spreadsheet and a living system.
Free data is surprisingly good. Census, DOT, FEMA — there's more free public data than most people realize.

Try It

I packaged this into a tool called SiteSweep — $79 one-time purchase, no subscription. Enter an address, get a full 10-factor report with a letter grade in seconds.

It's built for small business owners, franchise operators, and commercial real estate investors who want data-driven site selection without enterprise pricing.

The whole stack runs on Cloudflare Workers with zero hosting costs. Deep dive on the architecture: How We Run SaaS With Zero Hosting Costs.

What factors would you add to the scoring algorithm? I'm always looking to improve the model. Drop your thoughts in the comments.

I Built a $99 Mitchell1 Alternative That Auto Shop Owners Actually Want

Jay Durango — Sun, 08 Mar 2026 06:15:52 +0000

Auto shop owners are getting ripped off by software subscriptions. Mitchell1 ProDemand charges $300+/month. Tekmetric wants $200+/month. RepairShopr takes $60+/month. For what? Work orders, a CRM, and parts tracking.

I built JRD Garage — a complete auto shop management system for $99 one-time. No monthly fees. No per-user charges. No surprise price increases.

Here's how it stacks up.

The Problem: Subscription Trap

If you run an independent auto repair shop, your software costs look something like this:

Software	Monthly Cost	Annual Cost
Mitchell1 ProDemand	$300+	$3,600+
Tekmetric	$200+	$2,400+
RepairShopr	$60+	$720+
ShopBoss	$200+	$2,400+

That's $720-$3,600/year just to manage work orders and customer info. For a small independent shop doing $30-50K/month in revenue, that's a significant line item.

And here's the kicker: you never own anything. Miss a payment? Your data is held hostage. They raise prices? You eat it or migrate.

What JRD Garage Does

Everything a small-to-mid shop needs, nothing it doesn't:

Work Orders

Create, track, and close repair orders
Labor + parts line items with automatic totaling
Print-ready invoices
Status tracking (pending > in progress > complete > invoiced)

Customer CRM

Full customer database with vehicle history
Service reminders and follow-up tracking
Notes and communication log per customer
Search by name, phone, plate, or VIN

Parts Tracking

Inventory management with cost/markup
Vendor tracking
Low-stock alerts
Parts-to-work-order linking

AI Call Scripts

Pre-built scripts for common customer calls
Estimate follow-ups, service reminders, upsell prompts
Customizable per shop

The Architecture (For the Nerds)

JRD Garage runs on Cloudflare Workers — serverless JavaScript at the edge. Here's why that matters:

User (any browser) → Cloudflare Workers (serverless) → KV/D1 (storage)

Zero hosting costs: Cloudflare's free tier handles 100K requests/day
Global edge deployment: Your shop management loads fast from anywhere
No server maintenance: No updates, no patches, no "server is down" calls
Scales to zero: When you're not using it, you're not paying for it

The frontend is vanilla HTML/CSS/JS — no React, no build step, no npm install nightmare. It just works. On any device. Any browser.

// Work order creation — it's really this simple
export default {
  async fetch(request, env) {
    const url = new URL(request.url);

    if (url.pathname === '/api/work-orders' && request.method === 'POST') {
      const order = await request.json();
      order.id = crypto.randomUUID();
      order.created_at = new Date().toISOString();
      order.status = 'pending';

      await env.SHOP_DB.prepare(
        'INSERT INTO work_orders (id, customer_id, vehicle, status, created_at, items) VALUES (?, ?, ?, ?, ?, ?)'
      ).bind(order.id, order.customer_id, order.vehicle, order.status, order.created_at, JSON.stringify(order.items)).run();

      return Response.json({ ok: true, order });
    }
  }
};

No Express. No middleware chain. No ORM. Just a Worker that handles requests and talks to D1 (Cloudflare's SQLite-at-the-edge database).

Side-by-Side Comparison

Feature	Mitchell1 ($300+/mo)	JRD Garage ($99 once)
Work Orders	Yes	Yes
Customer CRM	Yes	Yes
Parts Tracking	Yes	Yes
Invoicing	Yes	Yes
Multi-device	Yes	Yes (web-based)
AI Features	No	Yes (call scripts)
Hosting Cost	Included (you pay)	$0 (serverless)
Data Ownership	Their servers	Your instance
Price After Year 1	$3,600+	$99 (still)
Price After Year 3	$10,800+	$99 (still)

After 3 years with Mitchell1, you've spent $10,800+ and own nothing.

After 3 years with JRD Garage, you've spent $99 and own the software forever.

Who It's For

JRD Garage is built for independent shops doing 5-30 cars/day. If you're a 1-3 bay operation, a mobile mechanic, or a specialty shop (transmission, diesel, performance), this is your sweet spot.

It's NOT for:

Multi-location dealership service departments (use CDK or Reynolds)
Shops that need integrated parts ordering from specific distributors
Shops that require insurance/warranty claim processing

For everyone else? $99 beats $300/month every single time.

Try It

JRD Garage is available now at jrdconnect.com.

$99 one-time. No account required to browse. No credit card to "try free." Just pay once and it's yours.

If you're tired of renting your shop software, come check it out.

I'm Jay — I build one-time purchase software tools. No subscriptions, no monthly fees, no BS. Check out more at jrdconnect.com.

I Built an AI That Reads Your Screen and Auto-Fills Forms — Here's How

Jay Durango — Sun, 08 Mar 2026 06:05:04 +0000

Every day, millions of knowledge workers do the same thing: look at data on one screen, then manually type it into another application. Invoice numbers, tracking codes, customer details, form fields — copied by hand, one keystroke at a time.

I got tired of it. So I built Scan0tron — a desktop AI that literally sees your screen and auto-fills forms for you.

The Problem Nobody Talks About

We have AI that writes essays, generates images, and passes the bar exam. But somehow we're still manually copying data between windows like it's 1998.

Think about how much time you spend on:

Reading an invoice PDF → typing values into accounting software
Copying tracking numbers from email → pasting into shipping portals
Transcribing handwritten notes → entering into a CRM
Reading one spreadsheet → filling out fields in another app

This isn't "work." It's human OCR. And it's a massive productivity drain.

How Scan0tron Works

The concept is deceptively simple:

Capture — Select any window or region on your screen
Analyze — AI vision model processes the captured content, understanding context (not just characters)
Auto-fill — Extracted data populates into your target form fields automatically

The key difference from traditional OCR tools: Scan0tron doesn't just read text. It understands context. It knows that "INV-2024-0847" is an invoice number, that "$4,299.00" is a total, and that "Net 30" is payment terms. It maps fields intelligently.

┌─────────────────┐     ┌──────────────┐     ┌─────────────────┐
│  Screen Capture  │ ──→ │  AI Analysis  │ ──→ │  Auto-Fill Form │
│  (any window)    │     │  (contextual) │     │  (your target)  │
└─────────────────┘     └──────────────┘     └─────────────────┘

The Numbers: 50 Tasks Timed

I ran a benchmark: 50 common data entry tasks, comparing manual keyboard entry vs. Scan0tron.

Metric	Manual	Scan0tron
Avg time per task	3.2 min	12 sec
Error rate	4.1%	0.3%
Tasks/hour	18	180+
Time savings	—	94%

The accuracy improvement surprised me most. Humans make typos. AI vision doesn't fat-finger the keyboard.

Why Not Just Use ChatGPT?

ChatGPT can't see your screen. Neither can Gemini, Claude, or any cloud AI. They work with text you give them — they can't observe your desktop, read your open applications, or interact with your forms.

Scan0tron runs locally on your machine. It has direct access to your screen content. No copy-pasting into a chat window. No describing what you're looking at. Just capture → fill.

The Architecture (For the Nerds)

Electron desktop app (cross-platform: Windows, Mac, Linux)
Computer vision pipeline for screen region capture
AI inference for contextual understanding
Form mapping engine that matches extracted fields to target inputs
Zero cloud dependency — works offline, your data never leaves your machine

Pricing That Doesn't Suck

This is where I get opinionated. Most AI tools charge $20-50/month. That's $240-600/year for what is essentially a utility.

Scan0tron is $49. Once. Forever. No subscription. No "free tier" that cripples functionality. No usage caps.

I wrote about why we don't charge monthly fees if you're curious about the business model. TL;DR: Cloudflare Workers + Electron = $0/month hosting costs, so we don't need recurring revenue to stay alive.

Try It

If you spend more than 30 minutes a day on manual data entry, Scan0tron pays for itself on day one.

Get Scan0tron — $49 one-time

Built by Jay Durango — I build one-time purchase software tools that replace overpriced subscriptions.

What's your most tedious data entry task? I'm curious what workflows people would automate first. Drop a comment below.

How I Run 3 SaaS Products on $0/Month Hosting (Cloudflare Workers Architecture)

Jay Durango — Sun, 08 Mar 2026 06:01:14 +0000

Everyone tells you SaaS needs servers. Monthly bills. DevOps. Infrastructure.

I run 3 commercial products — and my hosting bill is $0/month.

Here's exactly how.

The Stack

Frontend: Static HTML/CSS/JS on Cloudflare Pages (free)
Backend: Cloudflare Workers (100K requests/day free)
Database: Workers KV + D1 (free tier covers everything)
Payments: CardPointe (no monthly fee, just per-transaction)
Email: MailChannels via Workers (free)
CDN/SSL: Cloudflare (obviously free)

The Products

Scan0tron ($49) — AI screen capture + auto-fill. Desktop app (Electron) talks to a Worker API for license validation.
JRD Garage ($99) — Auto shop management. Full work orders, CRM, parts tracking. All serverless.
SiteSweep ($79) — Location intelligence. 10-factor scoring algorithm rates business sites C through AAA.

All one-time purchase. No subscriptions.

Why This Works

Cloudflare Workers run at the edge in 300+ cities. Cold start is ~0ms (not Lambda's 500ms+). The free tier gives you:

100,000 requests/day
10ms CPU time per request
Workers KV: 100K reads/day, 1K writes/day
D1: 5M rows read, 100K rows written/day
Pages: Unlimited bandwidth

For context, 100K requests/day supports roughly 5,000-10,000 daily active users. That's enough to run a real business before you ever pay a cent.

The Math vs AWS

Service	AWS Cost	Cloudflare Cost
Compute	$20-50/mo (Lambda)	$0
Database	$15-30/mo (RDS)	$0
Storage	$5-10/mo (S3)	$0
CDN	$10-20/mo (CloudFront)	$0
SSL	Free (ACM)	$0
Total	$50-110/mo	$0

When you sell one-time-purchase software, every dollar of margin matters. Zero hosting means the first sale is pure profit.

The Architecture

User → Cloudflare Pages (static frontend)
     → Cloudflare Worker (API/logic)
     → Workers KV (key-value state)
     → D1 (relational queries)
     → CardPointe (payment processing)

No Docker. No Kubernetes. No EC2 instances to patch. No RDS backups to manage. No load balancers. No auto-scaling configs.

It just works. At the edge. For free.

When You Outgrow Free

At $5/month (Workers Paid), you get:

10M requests/month
30ms CPU time
Expanded KV and D1 limits

That supports 15,000-20,000 DAU. Most indie products never get there.

The One-Time Purchase Model

Monthly SaaS pricing exists because of monthly infrastructure costs. Remove the infrastructure costs, and suddenly one-time pricing makes sense.

$49 once → customer happy, margin preserved, zero churn to worry about.

I wrote a deeper technical breakdown here: The Zero-Cost SaaS Architecture

Building these at jrdconnect.com. Happy to answer questions about the architecture.