Full-stack renovation management for homeowners
ResiMuze
- Model
- Bounded LLM orchestration
- Framework
- Responsible AI governance
- Environment
- Production-ready Node.js / MySQL
The principle — The central design decision in ResiMuze was sequencing: governance infrastructure before AI features. Ownership-chained access control, entitlement tiers, rate limiting, and a normalized data model were built and validated before Gemini was integrated. That sequencing is what makes the AI trustworthy — every recommendation traces back to a verified user, a confirmed property record, and a structured third-party data response. The model never touches freeform input.
The controls — The governance model extends beyond the data layer. AI features are access-controlled by plan tier, rate-limited per user and server-wide, and configurable by administrators through a live dashboard without a code deployment or server restart. When limits are hit or features are gated, the system degrades gracefully — it does not fail silently or bypass the controls. And at every point where AI produces an output, a deliberate human action is required to convert that output into a system state change. There is no auto-award, no auto-commit, no speculative AI invocation.
The pattern — That architecture — structured intake, bounded models, human authority at the decision layer, and administrative control over deployment parameters — is the same pattern that responsible enterprise AI governance requires. ResiMuze is a working implementation of it, built in a production context with real users.
The Problem
Home renovation projects fail at the coordination layer. Budgets live in spreadsheets, bids arrive via text, floor plans exist only in contractors' heads, and there is no structured model connecting financial scope to physical execution. Homeowners lose decision-making leverage the moment a contractor is engaged — because the data is too fragmented to reason from.
The Solution
ResiMuze replaces fragmented tools with a single governed workspace. A normalized schema enforces budget integrity and ownership-chained access control. A browser-based CAD visualizer handles floor planning. AI accelerates the high-friction tasks — scope synthesis, bid analysis, ROI estimation — but the platform is complete and usable without it.
Key Features
Property & project portfolio
Multi-property dashboard with per-property project tracking, task management across Kanban and Gantt views, milestone tracking, and a global view of tasks due today.
8-category budget model
Budget allocation across Materials, Labor, Permits, Tools, Equipment Rental, Delivery, Other, and Contingency — with expense tracking and real-time budget vs. actual reporting per category.
Floor plan CAD visualizer
Browser-based 2D floor plan editor built on Konva.js. Wall drawing with live dimension badges, door/window apertures, drag-and-drop fixture library, wall status (existing/proposed/demo), and per-room area calculations.
Contractor & bid management
Private contractor directory, structured bid workflow from request through side-by-side comparison to award. AI-generated bid analysis surfaces gaps; the homeowner makes the final call.
AI-assisted scope generation
Google Gemini generates structured task lists and exportable scope-of-work documents (PDF and DOCX) from project descriptions. Rate-limited per user, admin-configurable, with static template fallback when the API is unavailable.
Document & photo management
File upload with category tagging, per-plan storage quotas enforced server-side, in-browser preview, and task-level attachment linking. Photos support room tagging and progress documentation.
Build & Deliver
-- Ownership chain: every resource traces back to a verified user
-- AI is never invoked until ownership is confirmed at the route level
-- 1. authenticateToken verifies JWT
-- 2. verifyProjectOwner confirms user → project → property chain
-- 3. Only then is the prompt built from validated DB records
router.get('/property/:id/recommendations',
authenticateToken, -- verified identity
async (req, res) => {
const ent = await getEntitlements(req.user.userId);
if (!ent.features.market_insights)
return res.status(403).json({ code: 'FEATURE_GATED' });
const property = await verifyPropertyAccess(
req.params.id, req.user.userId -- ownership confirmed
);
// AI prompt built from DB records only — no user text
const insights = await getInsights(property, req.user.userId);
const parsed = await callGeminiJson(prompt, 8192, true);
res.json(parsed);
}
);
AI governance architecture
Governance layer built before the AI layer
The sequencing decision was deliberate: the data foundation was established before any AI feature was introduced. Ownership-chained access control, parameterized queries throughout, and a normalized schema ensure AI models only ever receive structured, validated inputs — not freeform user text. This is what makes the AI output auditable. When Gemini produces a recommendation, it can be traced back to a specific property record, a specific Rentcast API response, and a specific project scope — all stored in the database before the model was ever invoked. The AI is a synthesis layer on top of a governed data model, not a substitute for one.
Resolution: Native // Scale: 1:1
Market intelligence
Structured data ingestion driving AI-based ROI decisions
Property valuation and comparable sales data is pulled from the Rentcast API, normalized to a consistent internal shape, and cached with a 7-day TTL before it ever reaches the AI model. Gemini receives structured JSON — estimated value, comp sales prices, bedroom/bathroom/sqft data, and the project's active renovation scope — and returns a ranked list of scope items by projected value-add with over-improvement risk flags relative to neighborhood comps. The model does not receive freeform user input at any point. Rate limits on Rentcast API calls are enforced at both the server-wide and per-user level, configurable by administrators without a code deployment.
// Entitlement check → rate limit check → AI call
// All three must pass. Each is independently configurable.
const ent = await getEntitlements(userId);
if (!ent.features.ai_assistant)
return res.status(403).json({ code: 'FEATURE_GATED' });
const rl = await checkGeminiLimit(userId); // DB-backed counter
if (!rl.allowed)
return res.status(429).json({
code: 'RATE_LIMITED',
retryAfter: rl.retryAfter // ISO timestamp of next window
});
// Rate limits are admin-configurable without redeployment
// GET /api/admin/settings → current effective limits
// PUT /api/admin/settings → { rate_limit_gemini_per_user_per_day: 20 }
// Stored in app_settings table, cached 60s, invalidated on save
Responsible AI deployment
Entitlement tiers, rate controls, and admin governance
AI features are not available to all users by default. Access is gated by an entitlement system that resolves a user's plan tier against per-user feature overrides stored in the database. Rate limits are enforced at the server level for all AI and third-party API calls — separately tracked per user and server-wide — and are configurable by administrators through a dashboard interface without requiring a code change or server restart. When an AI feature is unavailable or rate-limited, the system falls back gracefully: scope generation returns a static task template, market insights return a gated response. No AI call is made speculatively. This mirrors the intake governance model that responsible enterprise AI deployment requires.
// No automated award logic exists anywhere in the codebase.
// The only path to a status change is an explicit user action.
// AI produces analysis — stored, displayed, never acted upon
const analysis = await callGeminiJson(BID_ANALYSIS_PROMPT);
await db.run(
'UPDATE scope_sheets SET ai_analysis = ? WHERE id = ?',
[JSON.stringify(analysis), scopeId]
);
// Award requires deliberate user PUT with status payload
router.put('/bids/:id', authenticateToken, async (req, res) => {
if (!await checkOwnership(res,
verifyBidOwner(req.params.id, req.user.userId))) return;
// status: 'accepted' | 'rejected' | 'pending' | 'under_review'
// No field defaults to 'accepted'. No auto-selection logic.
const { status } = req.body;
// ...
});
Human-led decision layer
AI recommends — the human always awards
Across every AI feature in the platform, the output is a recommendation presented for human review, never an automated action. Scope sheets generated by AI are presented as drafts the user edits and approves before a document is committed. Bid analysis surfaces strengths, concerns, and a value score per contractor — but the award requires an explicit user action. ROI recommendations rank renovation scope items by projected value-add but do not initiate any project action. This boundary is enforced at the architecture level, not just by UI convention: there is no award endpoint that can be called without a deliberate user-initiated PUT request. The governance model is structural, not advisory.
Architecture
Frontend
React 18, React Router v6, Konva.js, Framer Motion, Axios
Backend
Node.js, Express.js, MySQL 8, JWT Auth, Google Gemini API
Deployment
Nginx reverse proxy on Linux VPS, Mapbox GL JS, Resend for transactional email