The expensive mistake in property management modernization is treating "the system is old" and "the system is wrong" as the same finding. A PMS that holds the ledger, leases, and unit records correctly is a system of record doing its job. What hurts is everything around it: the manual Monday export, the portal that shows yesterday's balance, the integration someone built with a shared login.
Brocoders wrote the source article and sells this work, so treat this as one vendor's engineering position, not a neutral survey. One scope note up front: the title says commercial, but every example in the source comes from residential, HOA, and rental portfolios. The patterns transfer, the case evidence doesn't prove commercial results.
Three options, and what each one costs
| Option | What changes | What it costs | Fits when |
|---|---|---|---|
| Replace the PMS | Ledger, leases, and workflows move to a new system | Migration of every lease and balance, retraining, a cutover period | Vendor support ends, or the system can't hold your lease terms |
| Rehost | Same software on newer servers or cloud | Infrastructure work only | Hosting is the risk, not the software |
| Build around | PMS keeps the books; portals, dashboards, and integrations connect to it | A fringe you own and maintain | The books are fine and the gaps are reporting, self-service, and connections |
The source's argument is that the third option gets picked too rarely. It quotes Yardi's Rob Teel on the same idea: buy the platform, build the fringe.
One rule: every record has one owner
Building around a system of record only works if each record type has exactly one owning system. Payments, balances, and units belong to the PMS. The fringe copies or displays them and never decides. Permissions and uploaded photos can belong to the fringe. Write that table down before writing code:
const OWNER = {
payment: "pms", balance: "pms", unit: "pms",
permission: "fringe", photo: "fringe"
};
async function readBalance(unitId) {
const rec = await pmsApi.getBalance(unitId); // read through the API
cache.set(unitId, rec, { ttl: 60 }); // display copy, never edited locally
return { ...rec, asOf: rec.fetchedAt }; // show freshness to the user
}
async function updateRecord(type, id, change) {
if (OWNER[type] === "pms") {
// vendor-supported channel only, retry-safe, PMS wins on conflict
return outbox.enqueue({ type, id, change, key: change.requestId });
}
return fringeDb.update(type, id, change);
}
Three details carry the weight. Reads go through the vendor API, and the source is blunt that writing straight into a hosted PMS database is usually not possible and unofficial connections should be avoided. The asOf field means a user sees how fresh a number is instead of trusting a stale one. And writes to PMS-owned records go through a queue with an idempotency key, so a timeout can't create a duplicate.
Where AI fits
The source's warning is about order. An agent reading a PMS through its API is only as good as the records it reads, and stale or duplicated records produce confident wrong answers. So AI features come after automated tests and a staging environment, not before. Its own example is modest: an assistant that drafts association news posts, running on a codebase that already has a test suite.
What this looked like in practice
C.I.A. Services has managed HOAs in Houston and San Antonio since 1984, with over 150 associations on its in-house PMS, RedDog NextGen. Brocoders built an owner and resident web app with five access tiers. It pulls live data from RedDog and the website without duplicating records, and writes owner updates and photos back to RedDog, which stayed the system of record throughout. It ships as a web app, so there's no app-store release cycle.
CondoGenie, Brocoders' own SaaS since 2018, is the live-modernization claim: nine years of data migrated while the business kept running, followed by a framework upgrade, an automated test suite, and a payments provider update. Active users went from 1,398 in 2019 to 19,324 in 2025. The source gives no downtime figure, so the claim is qualitative. Lake, a vacation rental marketplace, had its backend rebuilt in three months and runs 6 PMS partnerships, with connected properties growing from about 500 to 40,000.
The stack is React, Node.js, and TypeScript with multi-tenant architecture as a default and in-house DevOps. bcboilerplates.com covers auth and tenancy scaffolding, so early sprints go into the integration layer. The entry point is a fixed-scope software audit: $5,000 in 5 business days for one application, or $9,900 in 10 business days for a larger system, ending in a written refactor-or-rebuild recommendation.
Engineering checklist before you modernize
- Ownership table: each record type names one owning system, in writing.
- Read path: through the vendor API, with the data's age shown to the user.
- Write path: vendor-supported channels only, queued, idempotent, PMS wins on conflict.
- No direct database access to a hosted PMS, and no shared logins as integrations.
- Tests on every sync that touches money: payments, balances, and charges.
- Staging environment before any AI agent reads production data.
- Demos every two weeks, so a wrong assumption about the PMS surfaces early.
- Maintenance owner named for the fringe, since you now own it. If you're deciding between replacing a PMS and building around it, and want a second technical opinion on the ownership table, brocoders.com is a reasonable place to start that conversation.
Top comments (0)