Intelligent Building
Management Application

Understanding the vision

Your concept describes a mobile application that does something the current generation of inspection apps doesn't do well: it understands what it's looking at. Rather than simply storing photos and notes, it extracts manufacturing dates, serial numbers, warranty information, and service histories from the physical labels on appliances, fire-safety equipment, and building assets — then uses that data to predict when each item will need attention.

This is fundamentally three products in one shell:

• A data-capture tool that converts photos of stickers, tags, and QR codes into structured records — replacing today's manual photo-and-notes workflow used in tools like NetVendor and HappyCo.
• A lifecycle intelligence engine that knows the expected lifespan, warranty windows, and maintenance schedules for each asset category, and automatically schedules notifications and recommendations.
• A universal integration layer that pushes this data into the property management systems (Yardi, RealPage, Entrata) already in use across multifamily and hospitality.

The competitive landscape confirms the opportunity. HappyCo dominates the inspection space with template-based checklists but doesn't offer real OCR-driven asset intelligence. Inspectify recently launched OCR-based appliance capture, which validates the technical approach. No vendor currently combines all three layers above into a single, focused product — which is your opening.

Users & roles

The application serves two distinct customer segments with different needs and pricing logic. Identifying them clearly up front shapes everything from data models to onboarding flows.

Segment A — Individuals & homeowners

A single user managing their own home. They install the app, create a small inventory of assets (water heater, fire extinguisher, smoke detectors, appliances), receive maintenance reminders, and optionally see recommendations for local service providers when something needs work. One-time purchase or low monthly subscription.

Segment B — Multifamily & commercial property management

Property management companies running portfolios of dozens to thousands of units. They need multi-tenant data isolation, role-based access, integration with their existing PMS, and dashboard-level visibility for owners. Per-unit monthly subscription with volume tiers.

Within Segment B, the product supports three role levels:

• Technician — performs inspections in the field, captures asset data, completes work orders. Mobile-first.
• Manager — schedules inspections, reviews completed work, assigns tasks, manages staff. Web + mobile.
• Owner / Executive — portfolio-level dashboard with predictive analytics, capital planning views, asset condition trends. Web-first.

Feature breakdown

Features are organised into four tiers by priority and dependency. Tier 1 is the minimum viable product. Tier 2 adds the differentiating intelligence. Tier 3 covers PMS integrations, which are technically self-contained but have long external lead times. Tier 4 covers exploratory features best validated after launch.

How a scan works

To make the core experience concrete: a technician points the phone at a water-heater dataplate. Within one to three seconds, the app extracts the relevant fields, validates them against manufacturer rules, computes lifecycle status, and writes a structured record. Below is what the result looks like inside the app.

The structured record is written to the unit's asset list, scheduled into the maintenance calendar, and synced to the connected PMS when integration is active. The technician moves on; the system handles the rest.

Strategic recommendations

Before specifying the build, three recommendations that significantly affect cost, risk, and time-to-revenue.

Start with the homeowner, not the enterprise

The brief positions the property-management segment as the larger opportunity, and it is. But Segment B has long sales cycles (60–120 days), requires PMS partnerships, and demands enterprise-grade features before any contract is signed. Segment A — homeowners — is the fast lane to validation, provides real OCR training data, generates testimonials, and funds further development through subscriptions while the enterprise side matures.

Defer PMS integrations to Phase 2

Yardi, RealPage, and Entrata integrations are valuable, but each requires becoming an approved interface partner — a process that can take two to three months independent of code. Ship the core product first with CSV export and Zapier as a stop-gap; this covers 60% of the value while partnerships progress in the background.

Trim voice and stylus entry from MVP

Both are listed as "optional" in the brief and they are correctly classified. They add modest user value but consume disproportionate engineering effort. Add them in Phase 3 once the core captures pipeline is proven and stable.

Technology stack

The stack is selected for two objectives: speed of development (heavy AI-assisted coding) and operational simplicity (minimal infrastructure to manage). Every choice trades a small amount of theoretical optimisation for a meaningful reduction in build and maintenance effort.

Why this stack and not alternatives

Development approach

The proposal assumes active use of Claude Code, an AI-assisted development tool, throughout the project. This is not a marketing detail — it's a meaningful productivity multiplier (typically 30–50% for boilerplate, integrations, tests, and refactoring) that allows a solo senior engineer to deliver work that would otherwise require a small team.

Practically, this means:

• Faster feedback loops. Code review, test generation, and documentation happen in parallel with implementation rather than as separate phases.
• Higher coverage of edge cases. AI assistance excels at proposing the unhappy paths a human is tempted to skip.
• Lower total cost. The hourly rate stays the same; the hours required go down. This proposal's effort estimates already reflect AI-assisted productivity.

What does not change with AI assistance:

• Architecture and design decisions. These remain human judgement calls.
• External dependencies. PMS partnership approvals, App Store reviews, third-party API quirks — these run on their own clocks.
• User research and validation. No substitute for talking to real customers.

How the work is structured

Development proceeds in two-week sprints, each ending with a deployable build the client can install and test. Every milestone has a tangible deliverable — not a status report. The full progression is described in the next section.

Communication & visibility

• Weekly written status update with progress, blockers, and next-week plan.
• Two-week sprint demo via video call.
• Shared project board (Linear or GitHub Projects) with current tasks visible at all times.
• Direct channel (Slack / Telegram / email) for time-sensitive questions.

Milestones & deliverables

The project is structured into six core phases plus optional add-on phases for PMS integrations and advanced features. Each core phase has a working deliverable that can be tested, reviewed, and approved before the next phase begins — protecting both parties from misaligned expectations.

Optional add-on phases

The following phases can be commissioned independently after the core product launches, or run in parallel with the later core phases if budget allows.

Pricing & effort breakdown

Rates are quoted at $25 per hour, reflecting senior fullstack engineering work for an international client. Estimates are firm for each phase: if the work runs over due to my own scope error, the overrun is on me. If scope changes are requested, we agree the change and its cost before proceeding.

Recommended commissioning paths

Three realistic starting points, depending on appetite and timeline:

• MVP only (Phases 01–03, 05, 06) — $11,250 over ~15 weeks. Single-user homeowner product launched and revenue-capable. Skip multi-tenancy for now.
• Full core (Phases 01–06) — $15,000 over ~20 weeks. Complete commercial product for both segments, no PMS integrations yet.
• Full core + first PMS (Phases 01–06 + A3) — $18,000 over ~24 weeks. Enterprise-ready with Entrata integration (recommended first due to API quality).

Payment schedule

Payment is structured per phase, released upon acceptance of each phase's deliverables:

• 20% retainer on contract signing, prior to start of Phase 01
• Per-phase payment on acceptance of each phase, prorated from the retainer
• Final 10% on launch and acceptance of Phase 06

For add-on phases (A* and B*), the same per-phase model applies: 20% on commission, 80% on acceptance.

Terms & what's included

Included in the quoted price

• All design and development hours described in each phase
• Project setup: repository, CI/CD pipeline, staging environment
• Code reviews and self-testing
• Weekly written status updates and bi-weekly demo calls
• Source code (yours, with full ownership transferred on final payment)
• Technical documentation for all integrations and internal APIs
• Onboarding documentation for end users and admins
• App Store / Google Play submission and review correspondence
• Six months of warranty support for bugs in delivered work

Not included — billed directly by client to provider

• Cloud infrastructure — Supabase ($25–125/month), Vercel ($0–20/month), Cloudflare R2 image storage ($20–80/month depending on volume)
• Claude Vision API usage — typically $50–300/month at MVP scale, scaling with volume
• Apple Developer Program — $99/year
• Google Play Developer — $25 one-time
• Domain & email — ~$30/year
• PMS partnership / interface fees — varies; typically charged by the PMS vendor
• Stripe transaction fees — standard 1.5–2.9% + €0.25 per transaction, deducted from payouts
• Stock imagery, fonts, branding assets — if commissioned separately

I will set up all of the above on the client's behalf using credentials supplied by the client; the bills flow directly to the client, not through me.

Working assumptions

• Access to real label photos (50–100 examples across asset categories) for OCR validation during Phase 01.
• Decisions on visual identity (logo, primary colours) confirmed by start of Phase 02 — if not, I'll propose a starting point.
• Client provides timely feedback on phase deliverables (within 5 business days). Phases pause if review is delayed.
• Major scope changes (new features not listed here) are estimated and quoted separately before being added to the plan.

Intellectual property

Upon final payment, all custom-developed code, designs, and documentation become the client's property under a perpetual, royalty-free license. Third-party open-source libraries retain their original licenses. I retain the right to reference the project (anonymously if preferred) in my portfolio.

Post-launch support

Warranty period — included

Six months from final acceptance of Phase 06. Defects in delivered functionality — anything that doesn't behave as described in the scope — are fixed at no additional charge. Bug fixes are prioritised within 2 business days for production-blocking issues, 5 business days for non-blocking.

Ongoing support after warranty

Option A — Pay-as-you-go

For occasional changes, enhancements, or new features. Each request is scoped and quoted before work begins. Hourly rate: $25/hour. No monthly commitment. Best for stable products with predictable, infrequent changes.

Option B — Monthly retainer

For projects with continuous iteration or where rapid response is needed. Reserved hours per month, used flexibly across maintenance, small features, and consulting. Typical packages:

• 10 hours / month — $250/month ($25/hour effective)
• 20 hours / month — $500/month ($25/hour effective)
• 40 hours / month — $1,000/month ($25/hour effective)

Unused hours roll over for one month. Response SLA: 1 business day for retainer clients.

Next steps

If this proposal looks aligned with what you have in mind, the next conversation is short and concrete:

1. Confirm the starting scope — full core, MVP only, or core + first PMS. This determines the contract.
2. Schedule a 60-minute kick-off call to review open questions, agree the kick-off date, and align on the first sprint goals.
3. Sign the contract and pay the 20% retainer. Phase 01 starts within 5 business days.
4. I begin Discovery — and from week one, you have something tangible to look at.

If anything in this document doesn't match your expectations, that's expected on first pass. I'd rather adjust the scope, pricing, or approach now than discover mismatches mid-build. Email or call me with any concerns and we'll revise.