A.R.C., an iPhone app I designed and built for home inventory. It uses AI to recognize what you own, catalogs it, saves the reports, then calculates whether your policy actually covers it.
A.R.C. app
Wooden surface, kitchen interior
Project selection screen
Scroll. It fills the mat, then travels the frame
That is why about 60% of American homeowners are underinsured.
The 60% comes from industry estimates of how many homeowners have documented what they own, and how far short their coverage runs.
The Insurance Reality
Carriers know what they will pay out on a policy. Homeowners rarely know what they would need to claim, and the gap only gets wider, because things keep coming into the house with no paperwork behind them.
A standard homeowner's policy covers personal property at 50-70% of the dwelling amount, so a home insured at $400,000 carries somewhere around $200,000-$280,000 for the things inside it. Whether that is enough depends on whether the homeowner knows what they own and what it would cost to replace. Most don't.
The paperwork is what stops people. You open a spreadsheet, walk room to room, describe each item, look up what it would cost to replace, photograph it, and attach the receipt. Done properly for an average home, that takes 40+ hours. Hardly anyone finishes.
Existing Solutions
I downloaded every home inventory app I could find before I built this one. Some of them are the spreadsheet again: you still type in every item, attach every photo, and look up every replacement value yourself. The app adds a database and maybe cloud sync, and the work is the same.
The rest are insurance carrier tools, built to make claims easier for adjusters: dense, functional, made for someone who already knows what they are looking at.
So the job is the same in all of them. You identify each item and put a value on it, one at a time, and a better interface does not change that.
The Vision Layer
The fix is to change what the person has to do. You show the camera the room. It picks out what is there, estimates values, and sorts everything into categories, and your job turns into reviewing what it found.
Video takes this further. Perceptron's Mk1 model reads the physical world from footage. It reasons across frames, tracks objects through space, and picks up the spatial context a single photo misses. Sweep a room with your phone and Mk1 reads the whole thing.
So a whole house becomes a room-by-room scan that takes minutes.
Show the camera the room and review what it found
One photo of a room comes back as a list of what is in it.
Each item comes back named, valued, and sorted into a category. A video of the room works the same way.
The image passes through vision processing, object identification, value estimation, and archival, and each stage feeds the next. Every decision point runs against a confidence threshold. Processing times were measured under typical indoor lighting.
Image Capture
You photograph a room or a single item with the phone camera. No special hardware, no calibration.
Archive Entry. The item goes into your inventory: linked to a room, tagged with metadata, tied to the photograph it came from, and counted in the totals right away.
Vision Processing
The OpenAI Vision API takes the image and returns a structured read: what the object is, what it is made of, its style, its condition, and a rough era or manufacture period.
Financial Analysis. The documented total updates as you go, and it gets compared against the policy limit you entered. When what you own gets close to that limit, or passes it, the shortfall shows up as a dollar amount.
Value Estimation
Each identified object is matched against market replacement data. What it estimates is what the item would cost to replace today, which is the number insurance runs on. Depreciated value and the original purchase price do not come into it.
Category Assignment. Every item goes into one of thirteen categories: furniture, electronics, artwork, appliances, fixtures, textiles, collectibles, vehicles, tools, sporting goods, musical instruments, jewelry, documents.
Each one maps to a standard personal property claim classification.
The sub-categories are there so the valuation has enough detail to be accurate, and none of it asks you to know any insurance terminology.
Most common rooms: Living Room, Bedroom, Dining Room
Most common rooms: Office, Living Room, Kitchen
Most common rooms: Living Room, Hallway, Bedroom
Most common rooms: Kitchen, Laundry, Garage
Most common rooms: Kitchen, Bathroom, Dining Room
Most common rooms: Bedroom, Living Room, Bathroom
Most common rooms: Office, Display areas
Location: Garage, Driveway, Storage
The average value of one item in each category. Bars are sized against appliances, the highest. Vehicles has no bar because $5,000+ is a floor, and there is no average to draw.
The gap between the two shows as a dollar amount.
Documented value on one side, the limit you entered on the other.
Every item you document adds to a running total, and that total gets checked against your policy limit for personal property.
You set the coverage amount when you buy the policy and it tends to sit there. Meanwhile the stuff inside the house keeps changing: new furniture, an upgraded appliance, gifts, a few pieces inherited from your parents. A home that was covered five years ago might be $50,000 short today, and there is no way of knowing until something goes wrong.
A.R.C. puts a number on the gap: a dollar amount, tied to specific items in specific rooms.
Personal Items Coverage
Your policy covers your personal items for $38,000 and you have $49,630 archived, so you are $11,630 short.
Documented asset value
Compared against policy limits
Vinyl, turntable, shelves
Home inventory is a chore, and the brand had to make documenting your house something you might want to do.
So utility software got a warm, magazine layout. Asset cards are set like entries in a collection, room views like a gallery of your own things, and the financial summaries in the same type as the rest, not as a table.
The lockupI did the design, the engineering and the deployment, with AI helping the whole way through.
Python backend, Streamlit frontend, deployed on Vercel.
Building Solo
Solo means I made every decision and shipped every line. No engineering team, no PM handing out tickets, no design review, no QA. I found the problem, designed the fix, wrote the code, tested it, fixed what broke, and shipped it.
That turned out to be the fast way to work. When I noticed a problem, a fix could be live within hours. Friction I hit while testing got sorted in the same session, and a feature idea that came up mid-build got prototyped right then.
The tradeoff is that every decision is a prioritization call: what ships now, what waits, what gets polished and what only has to work.
AI-Assisted Development
Claude Code was my main environment the whole way through. I would describe what I wanted in plain language, read the code that came back, test it, talk through the changes, and ship. Then again for the next feature.
What that changes is where the bottleneck sits: less on syntax or knowing a framework, more on being clear about what the product should do, which is the design part.
That is a big part of why one person could make the whole thing in ten weeks.
Development Timeline
Weeks 1-2 went to checking the idea. Could computer vision reliably pick out household items from ordinary phone photos? I tested across lighting, angles, and room types. It could, with a few caveats that ended up shaping the UX.
Weeks 3-4 were the architecture: database schema, user flow, the room and item data models, authentication, storage. Everything else builds on those.
Weeks 5-6 were interface design and the build of it, at the same time, with no handoff between what I meant and what showed up in code.
Weeks 7-8 were the financial layer, the insurance gap calculation and the policy limit comparison.
Weeks 9-10 were the brand identity and visual system, the marketing site, and the go-to-market work, and then launch.
Every screen puts the money first: what you own, what it is worth, and whether it is covered.
Dashboard, room, item detail and report views, shown with representative data.
By hand the same job is an estimated 8 to 12 hours, so it runs 16 to 24 times faster.
These are V1 numbers from launch onward, and still early.
The same 73-item home, documented both ways. The 8-12 hours is an estimate. The 30 minutes is how long the app takes.
Ten weeks from idea to the App Store, in five two-week stages, one after the other.
A renovated house, years of collected objects, and nothing documented anywhere that would survive an insurance claim.
V2 is underway: native iOS, better scanning, deeper financial analysis, all on top of the V1 code as it stands.
It has real users.
It is a complete product, brand, code, financial logic and go-to-market, made by one person. That was not possible two years ago.
Brand Identity
Full-Stack Engineering
Go-to-Market Strategy
Streamlit
OpenAI Vision API
Perceptron Mk1
Supabase
Vercel
Claude Code