Case Study: VisualEstimate

1. Introduction

Overview:

VisualEstimate is a deck estimation platform that lets homeowners self-generate accurate, line-itemed deck quotes in minutes, and lets contractors turn those quotes into permit-ready construction plans automatically. Built for Joshua Harden, owner of Acumen Renovations, the platform replaces a manual, spreadsheet-and-phone estimating process with a guided quote wizard, a server-side calculation engine of roughly 1,000 material formulas, and an admin dashboard with built-in CRM.

The product is a standalone web hub at visualestimate.build that contractors link to from their existing websites, so it adds quoting capability without forcing anyone to abandon the sites, SEO, and backlinks they already have. Phase 1 launched as a single-tenant MVP for Acumen Renovations; the architecture was deliberately built to expand into a multi-tenant, white-label SaaS that Joshua can resell to other contractors.

Challenge:

Building VisualEstimate meant solving a mix of domain, technical, and go-to-market challenges:

• Translating decades of tradecraft into code: Joshua's pricing logic lived in a sprawling spreadsheet of roughly 1,000 interdependent formulas that had never been formally specified.

• Protecting the formulas as IP: The estimating logic is the business. It could not be exposed to the browser where competitors (or resold contractors) could lift it.

• Permit-grade output, not just a price: A quote number wasn't enough. Contractors needed a structural deck plan, joist and girder specs, and material lists clean enough for a permit office to approve without manual review.

• Multi-service, multi-tenant from day one: The system had to start with decks for one contractor but scale to fences, pergolas, and concrete across dozens of contractors without a rewrite.

• A non-technical founder with a failed first attempt: Joshua had a "dumbed-down" prototype built by an overseas team that was never production-ready, and he openly struggled to write requirements.

2. The Problem

Background:

Joshua has spent nearly 30 years in the trades and is, in his own words, "a big process person" who runs his business on checklists. He had been chasing this product for years, even commissioning an early prototype from an overseas team. That prototype technically worked, his sales rep used it to generate estimates, but it was built on an aging framework, the logic was brittle, and it was never something he could put in front of the public. He had also lost the requirements spreadsheet he'd painstakingly assembled, leaving the project effectively back at square one.

Underneath the false starts was a real, recurring cost: every estimate required a human to interpret dimensions, look up materials, apply pricing, and produce a quote. That doesn't scale, and it caps how many jobs a contractor can bid.

Pain Points:

• Manual, expert-dependent estimating that consumed time and bottlenecked sales volume.

• No self-service path for homeowners, who increasingly prefer instant online quotes over scheduling a call.

• A failed first build on an outdated stack that couldn't be shipped or scaled.

• No formal requirements, since the formula logic existed only in a spreadsheet and in Joshua's head.

• No reusable asset: estimates produced nothing beyond a price, no structural plan, no materials purchasing list, no captured customer data.

3. Our Solution

Discovery Process:

We began with deep market research and a structured discovery process. The research confirmed a real opportunity: the construction estimating software market is valued at $1.5B+ with 10%+ annual growth, and no existing competitor combined deck-specific formulas with white-label, multi-tenant reselling. Tools like Bolster ($299-499/mo) and ArcSite ($120-160/mo) were either expensive and complex or required CAD drawing skills and lacked deck logic. That gap became the product's positioning.

The biggest discovery insight was sequencing. Joshua had a broad vision (decks, fences, pergolas, concrete; a contractor marketplace; eventually roofing), but launching all of it at once would have buried the value and the timeline. We scoped a focused Phase 1 MVP (Joshua's own deck business) and a Phase 2 multi-tenant contractor portal, with roofing explicitly deferred to a future phase due to rendering complexity.

Proposed Solution:

• Customer-Facing Quote Wizard: A guided, no-login form where homeowners enter deck dimensions, choose materials (treated, cedar, entry and premium composite), and configure railings, stairs, and add-ons, returning a real-time, line-itemed price in about 5-10 minutes on desktop or mobile.

• Server-Side Calculation Engine: Roughly 30-40 quote formulas plus a ~1,000-formula materials engine, all translated from Joshua's spreadsheet into Python and executed on the backend so the IP is never exposed to the client.

• Permit-Ready Plan PDFs: Automatic generation of a construction-plan PDF with a top-view deck drawing and a detailed spec sheet (ledger, joists, girders, posts, spacing, flashing), plus an uploadable certification badge to build trust with plan reviewers.

• Admin Dashboard + CRM: Quote tracking, customer data management, search and filter, status workflow, and fully admin-tunable pricing variables and surcharges, no code change required to adjust prices.

• 3D Deck Visualization: Interactive in-browser deck rendering to help customers understand what they're configuring.

• Multi-Tenant Foundation (Phase 2): URL-slug-based contractor sites (e.g. /smithdecks/quote), per-contractor pricing, enable/disable services per contractor, and an oversight portal for Joshua to manage all contractors.

The customer-facing wizard walks homeowners through deck size, structure, decking material, railing, stairs, and a dozen optional upgrades, with pricing recalculating live at every step.

Technology Stack:

• Frontend: Next.js 16 + React 19 + TypeScript, Tailwind CSS, and shadcn/ui, deployed on Vercel. Three.js / React Three Fiber for 3D deck rendering, jsPDF for client-side documents, and PWA support.

• Backend: Django 6 + Django REST Framework (Python 3.12, uv package manager), serving the quote engine, materials engine, PDF pipeline, and email delivery.

• Database: PostgreSQL 16, running as a Heroku Postgres add-on in production and SQLite for local development and tests.

• Storage: Cloudflare R2 for generated PDFs and uploaded images.

• Email: Resend for transactional quote and notification delivery.

• Monitoring: Sentry for error tracking and performance tracing.

• Hosting / CI: Heroku (backend) and Vercel (frontend), with a 6-job GitHub Actions pipeline (security scan, lint, typecheck, test, Django checks, Docker build).

4. Implementation

Calculation Engine & IP Protection:

The core technical work was faithfully translating Joshua's spreadsheet into a server-side Python engine. Rather than re-keying a fragile 1,000-cell Excel file, conditional logic and formulas were transmitted in pieces and reconstructed, with a dedicated Week 1 spreadsheet-review session to lock down the logic. Every formula runs on the backend, so the estimating IP, the thing the whole business is built on, never reaches the browser. Manual override inputs let a contractor enter total square footage or linear footage directly for irregular shapes the calculator can't model.

From a single quote, the engine derives a full purchasing list — decking rows, framing lumber, post and concrete quantities, stair geometry, balusters, and fasteners — so the contractor knows exactly what to buy.

Permit-Grade PDF Pipeline:

A defining feature was producing output a permit office would accept. The PDF pipeline generates a deck construction plan (top-view drawing plus a structural spec sheet) and pushes it through Cloudflare R2 for storage and Resend for delivery. During pre-launch review we tightened this further: when an admin overrides a girder size (say 2x8 to 2x10), the change now surfaces in the page-2 spec sheet, not just the drawing label, and a regression test was added to guarantee that the girder you select is the girder the plan prints, with pier tributary loads recomputing automatically.

Admin-Tunable Pricing:

Pricing was built to be operated by Joshua, not by engineers. Cost variables, tax, and surcharges live in an admin settings panel. A good example of responsiveness to real-world feedback: a surcharge originally applied to large decks was flipped to apply to small decks under 500 sq ft, because fixed mobilization and crew-setup costs hurt small-job margins more. Both the threshold and the percentage stay editable in the dashboard.

The admin dashboard gives the contractor a single view of every quote, its status, and conversion metrics.

Every estimate is searchable and filterable by status, so no lead falls through the cracks. Each quote opens to a full detail view with the materials list, line-item overrides, and one-click PDF and construction-plan downloads.

Architecture & Quality:

The system was documented up front with twelve architecture flow diagrams (system topology, request lifecycle, auth, the 9-step quote wizard, the calculation engine, a 10-state quote status machine, the email/PDF pipeline, the database ERD, the admin flows, and the deployment pipeline). The backend ships with a multi-stage Docker build, a 6-job CI pipeline, pre-commit hooks, secret scanning, and a pytest suite, production hygiene built in rather than bolted on.

Challenges Encountered:

• Formula fidelity: Ensuring 1,000 translated formulas matched the spreadsheet exactly, validated through iterative review with the client.

• Permit-review trust: Making PDFs accurate and consistent enough that a local permit office would approve them with minimal manual review.

• Speed vs. accuracy: AI tooling accelerated parts of the workflow (including image generation for material options), but required human oversight to keep structural and pricing output correct.

5. Results

Product Outcomes:

• Launched a production deck estimation platform on its own domain, with a working customer quote wizard, admin dashboard, and automated PDF + email pipeline.

• Replaced a manual, expert-dependent estimating process with homeowner self-service quotes generated in minutes.

• Delivered permit-ready construction-plan PDFs with structural spec sheets and a certification badge, turning a quote into a reusable contractor asset.

• Built a multi-tenant, white-label foundation ready to onboard additional contractors and additional services (fences, pergolas, concrete).

Technical Achievements:

• A server-side, IP-protected calculation engine of ~1,000 formulas that keeps the client's competitive advantage out of the browser.

• An automated PDF pipeline producing accurate, permit-grade structural plans, hardened with regression tests so configuration changes can't silently break the output.

• A fully admin-tunable pricing system, so the contractor adjusts costs, taxes, and surcharges with no code changes.

• A modern, well-tested codebase (Next.js 16 / Django 6) with a 6-job CI pipeline, secret scanning, and full architectural documentation.

• A clean ownership handoff: because the client already controlled the domain, file storage, and email, the platform was never single-sourced, and hosting, repo, and monitoring were transferred to the client with no residual dependencies.

Business Impact:

• Scalable estimating: Quoting capacity is no longer capped by an expert's time.

• Lead capture: Email is required before the quote builder opens, so every estimate becomes a captured lead with stored customer data and pricing trends.

• A new revenue line: The Phase 2 multi-tenant portal positions VisualEstimate as a B2B SaaS the client can resell to other contractors, turning an internal tool into a standalone product.

• Operational continuity: Site verification before contract acceptance and a self-serve admin keep day-to-day operations in the client's hands.

6. Lessons Learned

Key Takeaways:

• Phasing a broad vision is what makes it shippable. Decks-first for one contractor, then a multi-tenant portal, then roofing, kept the MVP focused while the architecture stayed ready to expand.

• Protecting domain IP is an architecture decision. Keeping every formula server-side in Python was the difference between a defensible product and a spreadsheet anyone could copy.

• Output quality is a feature, not a detail. The permit-ready PDF, and the regression test guaranteeing it stays accurate, turned a price calculator into something a permit office and a contractor both trust.

• Build for the operator, not the engineer. Admin-tunable pricing and surcharges meant the client could respond to real margin pressure (small-deck costs) without a development cycle.

• A clean handoff is part of the deliverable. Mapping every account and service ownership up front meant the client could take full control with zero downtime and no lock-in.

7. Conclusion

Summary:

VisualEstimate turned 30 years of a contractor's hard-won estimating knowledge, trapped in a spreadsheet and a failed prototype, into a modern, defensible web platform. By translating ~1,000 formulas into a server-side engine, generating permit-ready structural plans, and giving the client an admin dashboard he fully controls, we delivered a focused Phase 1 MVP on a multi-tenant foundation built to grow into a white-label SaaS. The result is a product that scales estimating beyond one expert's time, captures every lead, and opens a path to a resellable B2B product, owned end-to-end by the client.