Skip to content

Stakeholder

Managing Scope Creep with Clients: A Single-Vendor Platform Becomes Multi-Vendor Mid-Build

A client changed an education platform from single-vendor to multi-vendor mid-build: a structural change, not a feature request. As Associate Project Manager, I asked for more time; the client declined but increased the budget instead. I split the added work so the developers already on the project handled what needed context, and new developers handled what did not. The original delivery held, and Phase 2 shipped after it.

HighPublished

At a glance

A client changed an education platform from single-vendor to multi-vendor mid-build.

  • Asked the client for more time; they declined but increased the budget instead
  • Rearranged the sprints to carry the added scope
  • Split the new work so developers already on the project handled what needed context, and new developers handled what did not
Result

The original delivery held on date. Phase 2 shipped after it, and the client rated the engagement 5 stars, added a bonus, and chose the same team for their next project.

The situation

The platform was built as single-vendor. Partway through, the client changed the requirement to multi-vendor: institutions and individual teachers each needed their own profile and the ability to sell courses through the platform. That is not a feature request, it is a different platform underneath the same brief. I was Associate Project Manager at the time, still inside my provisional period.

How it surfaced

A scope change reads differently from scope creep the moment you size it. This was not several small asks that add up: it was one structural change that touched the data model, the checkout flow and the account system at once. I treated it as a re-scoping conversation, not a change-request queue.

What I ruled out, and why

I went to the client with the size of the change and asked for more time. They declined: the launch date mattered more to them than the schedule did. What they offered instead was budget, which meant the real constraint was not the added scope, it was the calendar. That reframed the problem: I could not buy time, so I had to buy capacity inside the time that already existed.

The decision and what it cost

I brought new developers onto a project that was already underway, which is normally the expensive move: a new person costs the team that trains them before they add anything back. I decided to split the work instead of splitting it evenly: the developers already on the project, who already carried the context, took the foundation work that depended on it. The new developers took the frontend implementation against a plan that did not require that context to execute. That kept the training cost close to zero.

What I did

The sprints were rearranged to carry the increased scope inside the remaining timeline. The developers already on the project built the foundation: the parts of the multi-vendor change that touched what they already understood about the platform. The new developers implemented the frontend against the plan the existing team had laid out, working from a defined plan rather than from the platform's history.

The outcome

The original delivery shipped on date. Phase 2 (the multi-vendor work) shipped after it. The client rated the engagement 5 stars, added a bonus on top of the contract, and chose the same team for their next project.

What stayed changed

Adding people to a late project costs exactly what it is reputed to cost, if you add them to the part of the work that needs context they don't have. It does not cost that if you route them to the part that does not need it. That split was the decision, not "we added more developers." I look for that seam now before I bring anyone new onto a project already underway.

Related incidents

High
Architecture Decision

When the Platform Could Not Carry the Product: Moving to Headless WordPress with Next.js

Close to launch, a large-scale US civic information platform's client brought behaviors plain WordPress could not run: an address-based sample ballot live from the Google Civic API, an interactive polling-place map, and a 700+ candidate directory with real-time filters. I told the client directly the platform could not carry it, negotiated $1,000 and one more month, and split the architecture: WordPress for content and commerce, Next.js for everything interactive. The platform launched, and the client is now building mobile and iOS apps on it.

  • Google Civic API
  • JetEngine + WooCommerce
  • API-First Backend
View Details
Critical
Implementation Gap

A Launch Delayed an Hour by an Undisclosed Implementation Choice

Ahead of a SaaS launch for an international client, I asked a developer to build one API route pulling the admin dashboard's data from multiple tables at once. He built several separate calls on the same page instead, and didn't tell me. I fixed the query layer myself with indexing and a rewritten query, and told the client the launch would be about an hour late, rather than let a slow admin page surface on its own.

  • SQL Indexing
  • Query Rewrite
  • Undisclosed Change
View Details
Medium
Pre-Build AuditIn progress

Reading the Architecture Before Writing the Code

A partner developer I work with as Technical PM brought me a project through Exprovia: his client's technical proposal for a bilingual e-learning platform for professionals across Africa looked finished. Auditing it against vendor documentation and cost math surfaced four assumptions that would not have survived the build, all revised in one meeting before a sprint started.

  • Architecture Audit
  • Vendor Cost Modeling
  • Offline-First Design
View Details