The Rightmove conversation that changed everything
"Looks great, but can it push to Rightmove?"
That question came up in three separate conversations with agencies. Not "nice to have"—deal breaker. If LetAdmin can't syndicate properties to Rightmove, agencies won't even consider it.
Fair enough. Rightmove dominates UK property searches. If your properties aren't there, you're invisible to most prospective tenants.
But here's the thing: Rightmove's integration is complex. P12 certificates, nested JSON payloads, strict data requirements. I could spend two weeks building a Rightmove-specific integration... or I could spend two weeks building integration infrastructure that makes Rightmove (and every future integration) straightforward.
I chose the latter. Scary decision—what if I'm wrong?
Webhooks: the feature I wasn't sure anyone would use
Webhooks are how modern systems talk to each other. When something happens in LetAdmin (property created, status changed, photo uploaded), webhooks instantly notify other systems.
The problem? Nobody explicitly asked for webhooks. They asked for Rightmove, Zoopla, Xero integration. Webhooks are the plumbing underneath those features.
Building infrastructure before anyone asks for it feels premature. You're creating something that might not get used, might not work how people need, might be solving the wrong problem.
But the alternative—building custom integrations one-by-one—scales terribly. Integration three takes as long as integration one. Every new feature requires updating every integration. It becomes unsustainable fast.
So I built webhooks properly: HMAC signatures for security, automatic retries when deliveries fail, tracking so you can see exactly what fired when. The kind of webhook system that Stripe or GitHub would build.
Will agencies care? Honestly, most won't even know webhooks exist. But developers building integrations will, and that's what matters.
The apps marketplace (before there's a marketplace)
Here's an ambitious idea: what if agencies could install integrations like installing apps on their phone?
Browse available integrations, click "Install," enter your API credentials, done. No custom development, no waiting for features, no technical support needed.
This week I built the apps architecture that makes that possible. Each app (Rightmove, Zoopla, Xero, whatever) defines what configuration it needs using JSON Schema. The system automatically generates the settings form. Agencies configure once, and it just works.
Does this seem premature when I only have one integration? Probably. But building the second integration will prove whether the architecture works, and every integration after that should be dramatically faster.
Rightmove: the brutal reality check
Theory is great. Practice is brutal.
Rightmove's API requirements are... comprehensive. Properties need council tax bands, outside space types, parking details, deposit information—dozens of fields I hadn't needed before. Their photo requirements are specific. Their authentication uses P12 certificates which are notoriously fiddly.
But because I'd built proper integration infrastructure, I could focus on Rightmove's specific requirements rather than reinventing webhook delivery, retry logic, and configuration management.
Did everything work first try? Absolutely not. But when things broke, they broke in predictable ways that the infrastructure handled gracefully. Failed deliveries retried automatically. Errors logged clearly. Configuration validated before causing problems.
That's the value of building infrastructure properly.
The Sidekiq migration nobody noticed
Midweek I swapped out the entire background job system. Migrated from Solid Queue to Sidekiq, set up Redis, configured priority queues.
Why? Solid Queue is fine for simple needs, but Sidekiq handles the scale I'm aiming for. Stripe runs millions of background jobs through Sidekiq. GitHub processes webhooks through Sidekiq. If it's good enough for them...
The best part? Because I'd properly abstracted the job system, the migration was transparent. All existing jobs kept working. No downtime. Nobody noticed.
That's what good infrastructure looks like—it gets out of the way.
What agencies actually get
If you're running a letting agency, this week probably sounds abstract. Webhooks? Apps architecture? Who cares?
Here's what you actually get: when you ask "can LetAdmin integrate with [thing]," the answer is increasingly "yes, and it'll only take a week to build" rather than "that'll take two months of custom development."
Want properties automatically syncing to Rightmove? Done. Need tenancy data pushing to your accounting system? The infrastructure's ready. Custom integration with your existing software? Webhooks make it possible.
The infrastructure I built this week doesn't make LetAdmin better today. But it means LetAdmin can grow to support whatever integrations agencies need without me having to rebuild everything for each one.
That's the bet I'm making: build the infrastructure that makes future development fast, even if it feels premature now.
What I learned
This was the first week where I explicitly bet on the future rather than just solving today's problem.
Building integration infrastructure before having multiple integrations feels wasteful. But building integration three with the same manual approach as integration one? That's definitely wasteful.
The question isn't "do I need this now?" It's "will I need this soon enough that building it now is worthwhile?"
For integration infrastructure? Yes. Definitely yes.
Next week: more property features. But now with the confidence that whatever I build can integrate with the rest of the property technology ecosystem.