iAmEvolving – Custom WordPress Platform
iAmEvolving
We build and modernize WordPress platforms for organizations where the website is one system among several: data that lives in someone else’s system of record, content at a scale nobody can hand-manage, more than one group with a say in the release, and no appetite for the site being down while it happens.
“Enterprise” is used loosely enough in WordPress to have stopped meaning anything. It is worth replacing the adjective with the conditions it is standing in for, because those conditions are what change how a project has to be built. It is entirely possible to have a large budget and none of them, or a modest budget and all six.
The website is not the system of record. Advisors, members, products, rates or availability are owned by a CRM, an internal platform or a partner, and WordPress has to present them accurately without becoming a second, diverging copy.
Communications, IT, legal, accessibility and a business owner all have standing. That changes the shape of the work: written specifications, staged review, and a record of what was decided and by whom.
Thousands of records, a decade of archives, structured entities with relationships between them. At that scale the content model is the product, and getting it wrong is not a refactor, it is a migration.
Changes cannot go straight to production. That means environments, a build pipeline, a rollback path and a definition of who approves what.
The platform will outlast the project, the agency relationship and probably several of the people who specified it. Maintainability and documentation are deliverables, not courtesies.
Complex platforms fail in the plan, not in the syntax. The decisions that are expensive to reverse (how content is modelled, where each piece of data is authoritative, how the site is split into sites, how editors will actually work) all get made in the first weeks, and most of them are made implicitly if nobody makes them deliberately.
We start with a written architecture: the content model and the relationships in it, the integration map with the direction and frequency of every data flow, the environment and release plan, the editorial roles, and the parts of the system that are deliberately out of scope. It is short, it is reviewable by people who are not developers, and it is the thing a second developer reads in two years to understand why the platform is shaped the way it is.
This is also what makes a fixed-scope tender response possible. A phased estimate is only meaningful if the phases correspond to decisions someone has already made.
Most enterprise WordPress problems present as editorial complaints: the site is slow to update, nobody can find anything, two teams have published contradictory versions of the same thing. Almost all of them are content model problems underneath.
Custom post types and taxonomies that describe what the organization actually manages (people, locations, programs, documents, products) with the relationships between them modelled rather than duplicated in prose.
A curated set of server-rendered blocks instead of an open page builder. Editors assemble pages from components that already carry the right structure, markup and accessibility behaviour, and the design system stays intact as the site grows.
Who can publish, who can only draft, who can touch the navigation, who can edit the legally reviewed pages. Mapped to real responsibilities rather than to WordPress’s default five roles.
Preview that shows the real rendered page, a staging environment content owners can actually reach, and a publishing flow that does not require a developer to be online.
At scale, editors need to move, retag and correct hundreds of records at once. If the only tool is the post list, the content decays.
In the platforms we build, WordPress is usually the presentation and editorial layer over data that belongs somewhere else. That is a design position, not a limitation: the integration is what keeps the website accurate without asking anyone to maintain the same record twice.
In delivered work this has meant broker, office and franchise data from a client’s own CRM, calendar and scheduling services, mapping and location services, payment processing, weather and external data feeds, consent management, and analytics and tag management, all built against documented APIs with caching, logging and defined behaviour when the upstream system is unavailable.
The last part matters more than the integration itself. An integration that works is ordinary; an integration that degrades predictably when the other system is down, rate-limited or returning something unexpected is the difference between a platform and a demo.
External calls are cached deliberately, with an invalidation strategy, so a slow upstream service does not become a slow website.
Errors are logged with enough context to diagnose them, and the front end degrades to something sensible rather than to a stack trace or an empty page.
Service accounts, token exchange and credential storage done in code and in configuration, never in the database or in a repository.
Tell us what the platform has to do, which systems it has to talk to, and who has to sign off. We scope in phases and estimate each phase in writing, so you can see what every part costs before committing to all of it.
Enterprise delivery is mostly about making changes boring. The platforms we run are deployed from version control through a build pipeline into staged environments (local, staging, production) with the same build producing the same artefacts each time, and a documented path back if a release goes wrong.
We have delivered this on cloud infrastructure, including Azure virtual machines with CI/CD pipelines, and on conventional managed hosting. The infrastructure is chosen to fit the client’s IT constraints rather than our preferences. Where an organization needs standalone managed hosting rather than a development partner, we will say so and point them elsewhere rather than sell it.
Everything that defines the site (theme, blocks, configuration) lives in the repository. Nothing important exists only on the server.
A staging environment that matches production closely enough to be worth testing on, and that stakeholders can reach without a developer’s help.
A pipeline that builds, tests and ships on a merge, so releases are repeatable and a rollback is a known procedure rather than an improvisation.
What changed, what it affects, and what to check after. Written for the client’s IT and communications teams, not only for the next developer.
At scale the ordinary WordPress advice stops being sufficient. Performance work becomes query and content-model work: an unindexed meta query over fifty thousand records will not be rescued by a caching plugin, and a page that assembles twelve external calls per request needs its data strategy fixed rather than its cache warmed. We work on Core Web Vitals from the template and query layer up, with caching as the last step rather than the first.
Security at this level is mostly governance. Who has an administrator account and why, how credentials are stored, which plugins are permitted and who approves a new one, how quickly a critical patch gets applied, and what the recovery procedure actually is. We document these as part of handover because they are the questions an IT reviewer asks in procurement, and because a platform with no named owner for them is one staff change away from being unmaintained.
Where an organization runs several related sites, whether divisions, brands, regions, campaigns, or an English and a French presence, a multisite network lets them share a codebase, a design system and a release process while keeping content and permissions separate. It is the right answer often, but not always, and the decision belongs in the architecture phase rather than in the build.
The clearest examples in our portfolio are five mortgage and brokerage platforms: Multi-Prêts, Mortgage Alliance, Invis, Mortgage Intelligence and Intelligence Hypothécaire, five brands of the M3 Tech group on one shared codebase. They share the conditions described above: broker, office and franchise data owned by the client’s CRM and read over an authenticated API, calculators and tools that have to be right, a bilingual presentation of the same content model, a Gutenberg block library in the parent theme for the editorial teams, structured data for search, consent management, and hosting consolidated behind CI/CD pipelines.
Doolittle Lake Club is a different shape of the same problem: a private members’ portal with role-based access, document management, calendar and external data integrations, where the requirement was controlled access and reliable operation rather than scale.
Each case study sets out what was built and what it involved.
An enterprise platform is not finished at launch; it enters its longest phase. We stay on as the development team, covering core and plugin updates, security patching, monitoring, integration changes when an upstream API version moves, performance work as content grows, and new development as requirements change. It is handled by the people who built the thing, working against the architecture they wrote down.
Where an organization would rather bring the work in-house or move it to another supplier, the handover is the documentation, the repository and the architecture record. A platform you cannot hand over is a platform you do not own.
Not budget. The conditions that change how it has to be built: the authoritative data lives in another system, several groups have standing in the decisions, the content is past the scale anyone can manage by hand, downtime has a cost so releases need a process, there are accessibility or privacy or language obligations attached, and the platform has to survive the people who specified it.
Yes, with the caveat that the failures at scale are architectural rather than platform limits. Large content sets need a content model designed for them and queries written against it; heavy integration needs caching and failure handling; heavy traffic needs infrastructure and a caching strategy. We have built and run platforms with external data integrations, bilingual content models and cloud deployment pipelines.
Routinely. In most of this work the infrastructure, the security requirements and the systems we integrate with belong to the client’s IT group. We work to their constraints, document what we build for their review, and expect their sign-off on architecture and release process.
Often. It starts with an assessment of the codebase, the hosting, the integrations and the content model, and an honest answer about what can be maintained in place and what should be rebuilt. That answer is worth having before a commitment either way, and we would rather give an unwelcome one early.
Yes. Written architecture, integration and data flow documentation, accessibility and security information, environment and release process, and a support model. These are normal deliverables in this work rather than extras, and they are what an IT or procurement reviewer actually reads.
Sometimes. It fits when several sites should share a codebase, a design system and a release process while keeping content and permissions separate: divisions, regions, brands, or a bilingual pair. It fits badly when the sites have genuinely different architectures or need independent release schedules. It is an architecture decision, and we make it deliberately before the build rather than by default.