The inspection that taught me everything
Picture this: an agent walks into a basement flat to conduct a routine inspection. She opens LetAdmin on her phone, starts documenting room conditions, takes photos of a damp patch in the kitchen, and... nothing happens. No internet. Thick walls, basement location, dead zone.
She tries to submit the inspection. Error. Her work disappears. She has to start over, but this time using a paper checklist.
This happened. An early adopter told me about it, and I felt terrible. I'd built inspection forms that only worked online. Which meant they didn't actually work for the job they were supposed to do.
This week I rebuilt inspections to work offline-first. It was the hardest technical challenge I'd faced so far.
Why inspections are different
Most property management happens in an office. Adding properties, updating rent, running reports—you're sitting at a desk with good WiFi. No problem.
But inspections? Inspections happen at properties. Rural cottages with weak signal. Basement flats with no reception. Old buildings with thick walls that block 4G. And agents need to document property condition, upload photos, collect signatures, all while standing in these connectivity black holes.
The traditional web application approach fails completely: click submit without internet, and your work disappears. Leave the page, and everything's gone. Refresh, and it's all lost.
Agents learned to avoid the system. They'd use paper checklists, take photos on their personal phones, then spend an hour back at the office manually entering everything. Exactly the inefficiency software is supposed to eliminate.
I needed to build something that worked offline by default, not as an afterthought.
The offline-first challenge
Here's what makes offline-first architecture tricky: you need to store everything locally in the browser, keep the interface responsive while saving data to IndexedDB, sync with the server when connectivity returns, handle partial failures gracefully, and somehow make all of this transparent to users.
Oh, and it needs to work on phones and tablets that agents actually carry on-site, not just desktop browsers.
This week I rebuilt inspections with proper offline support:
Local storage using IndexedDB. Everything saves to the browser's database first. Photos, notes, signatures—all stored locally immediately.
Background sync. When connectivity returns, the system automatically uploads everything to the server. No manual "sync now" buttons.
Mobile-optimized. Photo uploads compress large images automatically. Signatures work through touch interfaces. Forms adapt to phone screens.
Progress feedback. When syncing happens, you see exactly what's uploading and how it's progressing.
Graceful failures. If a photo upload fails halfway through, the system remembers where it left off and resumes automatically.
The technical disasters along the way
I'm going to be honest: building this nearly broke me.
First attempt: manual DOM manipulation to handle photo uploads. Broke completely on mobile browsers in ways I couldn't reproduce on my laptop.
Second attempt: refactored to use Alpine.js reactive patterns. Better reliability, but revealed IndexedDB corruption issues. Photos would save but fail to load later.
Third attempt: switched to base64 encoding for images. Finally worked reliably, but now I had to handle large base64 strings which browsers can struggle with.
Fourth attempt: added compression before encoding, progress indicators during upload, chunked sync for large inspections, and paranoid error handling everywhere.
Each iteration made it more robust, but each iteration also revealed new problems I hadn't anticipated. The worst part? Most issues only appeared on actual mobile devices with real network conditions. Couldn't reproduce them in desktop Chrome's mobile simulator.
I spent two days debugging why photos uploaded successfully but disappeared after sync, only to discover it was a race condition in the IndexedDB transaction handling that only occurred on iPhone Safari under specific network conditions.
Fun times.
What agencies actually get
If you're running a letting agency, here's what this week means for you:
Inspections that actually work on-site. Your staff can conduct complete inspections underground, in rural areas, or anywhere else with poor reception. The system works offline by default.
No lost work. Connection drops mid-inspection? Doesn't matter. Everything saves locally first, syncs automatically later.
Automatic photo compression. Staff can take high-resolution photos without worrying about data usage or slow uploads. The system handles compression automatically.
Digital signatures anywhere. Collect tenant or landlord signatures through touch interfaces, no internet required.
Mobile-first interface. Forms designed for phones and tablets, not desktop browsers pretending to be mobile-friendly.
Transparent syncing. When connectivity returns, everything uploads automatically in the background. No manual sync buttons, no lost data.
What I learned
This week taught me that "offline-first" isn't a nice-to-have feature—it's essential for any system that expects users to work in the real world.
I also learned that building offline-first web applications is genuinely hard. Browser storage APIs have quirks. Mobile browsers behave differently than desktop. Network conditions in real properties are worse than you think. Testing requires actual devices in actual locations.
But most importantly, I learned that watching someone fail to use your software is the best motivation to fix it properly. That agent with the paper checklist in the basement flat? She's using LetAdmin now, offline, and it just works.
Sometimes you need to rebuild something from scratch because your first attempt wasn't good enough. That's not failure—that's learning what actually matters.
Next week: taking all this inspection data and actually doing something useful with it. Automated reports, landlord communications, the works. But at least now I know the foundation is solid.