
Architecture as Margin
Architecture decisions get made in a sprint and paid for over years. I make the bill visible while the choice is still open.
Build-vs-buy, abstraction layers, shared foundations: each one sets the price of every change that comes after it. I lead engineering where those choices are costed before they’re made, not discovered in a maintenance budget two years later.
What this looks like
Build-vs-buy rigor: Vendor evaluations grounded in total cost of ownership and proof-of-concept testing against real workloads, not demos.
Multi-tenancy as economic strategy: Shared infrastructure serving hundreds of deployments from a handful of codebases, with per-client variation handled by configuration.
Debt reduction as velocity investment: Platform work priced by what it takes off every future sprint.
Architectural decoupling as autonomy: Service boundaries drawn so a team’s release cadence isn’t set by someone else’s approval calendar.
How I’ve done it
Turning 37 codebases into 8
I inherited a fragmented mobile portfolio: 37 separately maintained iOS and Android codebases, each one a slightly different version of the same product. Every SDK update, store policy change, and build-system upgrade had to be made 37 times. Coordination cost was the problem, not coding speed.
I designed and led the migration to a multi-tenant architecture, consolidating those 37 into 8 configuration-driven codebases. What had been linear cost became leverage. Each new client needed configuration, not infrastructure.
The platform grew to 200+ white-labeled applications on four disciplined shifts:
Configuration-driven behavior: Features, theming, content, and environment set by tenant config files rather than code branches.
Standardized build systems: CI/CD pipelines that eliminated per-client build drift and kept build times predictable.
Automated release management: App Store and Google Play publishing workflows that took engineering out of the path of every release, policy change, and SDK update.
85% automated test coverage: The safety net that made shared-codebase changes safe at scale.
Client onboarding went from weeks to days, and one change to a shared codebase reached every tenant built on it.
Making build-vs-buy a discipline, not a debate
At Dayforce, I led vendor evaluations for fraud detection, feature flagging, and engineering analytics. Each one would shape platform capability for years. Rather than defaulting to build or chasing demos, I put a standing assessment in place:
Financial modeling: Total cost of ownership for vendor solutions against internal build cost, including the opportunity cost of engineering time.
Proof-of-concept validation: Engineering tested vendor solutions against real workloads before any commitment.
Alignment reviews: Product, finance, and engineering leadership evaluated strategic fit and long-term maintainability together.
We bought where vendor maturity exceeded what we could build on our timeline, and built where domain complexity made off-the-shelf a liability. The individual calls mattered less than what they left behind: the next decision had a method waiting for it.
Decoupling delivery from enterprise governance
Leading mobile engineering at iSeatz, inside the $10.7B+ travel and loyalty platform behind Amex Travel, I hit a structural problem. Our delivery cadence was set by enterprise approval cycles. The monthly governance reviews were non-negotiable, and they were capping how fast we could iterate.
I redesigned the release architecture around integration contracts: specifications defining API boundaries, security models, and operational permissions between mobile clients and platform services. Our teams moved to biweekly cycles while the enterprise kept its monthly governance cadence. We decoupled without diverging.
The constraints didn’t change. The architecture did.





