Skip to content
intermac
Journal
Product

3 min read

The core/flexible split that actually makes fixed-price projects survivable

A framework for delivering fixed-price software projects with unclear scope, where the real leverage isn't the contract language—it's an architectural decision made early.

By intermac

Most teams treat scope uncertainty as a project management problem. The case study Karol Wojciszko published suggests it's really an architecture problem in disguise.

The story: a small software house takes a fixed-price pharmaceutical project roughly ten times larger than anything they'd done before, with requirements written at the level of "reports" and "planning." They deliver all three phases on time. The framework they used is worth unpacking, because the most useful part isn't the milestone structure or the contract negotiation—it's one design decision.

The split that did the actual work

Wojciszko separated requirements into two buckets: core, meaning anything whose change would break completed work, and flexible, meaning module-level details that could evolve freely. The core was essentially architectural—the relationships between objects in the system. Report columns were flexible; the data model was not.

This isn't a new idea in software design, but framing it as a negotiating and delivery tool is underused. Once the client signed off on the core, every scope discussion changed character. When a stakeholder wanted to change something, the team could check whether it touched core or not. If it didn't, the answer was "no problem." That phrase did two things at once: it gave the client permission to keep thinking, and it protected the team from expensive rework.

The architectural consequence followed directly. They built a custom system out of configurable, switchable modules rather than reaching for an off-the-shelf CRM. That decision looked expensive up front but absorbed the constant scope movement without requiring rebuilds.

If you're designing a system where the requirements are still being discovered—and that's most systems—the first question worth asking is: what are the relationships and constraints that everything else will sit on top of? Lock those down early, formally if possible. Everything else can move.

Two other things worth taking seriously

Kill the jargon before the first meeting. Wojciszko admits he explained Scrum, waterfall, and time-and-materials pricing to a room of pharmaceutical executives who had never worked with an external software vendor. They nodded. The nods weren't agreement. The practical difference between methodologies is "you'll see working software every few weeks" versus "you'll see everything at the end." That's one sentence. Preparing those one-sentence explanations before any stakeholder meeting is worth more than a polished deck.

Team intuition beats most formal metrics on novel projects. His team couldn't find a velocity or earned-value formula that tracked the real risks—superficial client feedback and silent scope drift. What worked was a standing question: "Are you confident what we're building is what they actually need?" The modules the team felt uncertain about were exactly the ones that needed the most revision. If you manage engineers, that informal signal is data. Build it into your regular cadence.

The honest trade-off

The standard advice—don't take fixed-price contracts with unclear scope—is correct most of the time. Wojciszko says so himself. The case for sometimes saying yes anyway isn't that the risk disappears; it's that structure can make the risk manageable. Milestones that deliver independent value, a core that doesn't move, and a team with real access to the people who do the work every day.

The system launched on time and the client actually used it. That second part is rarer than it should be, and it follows directly from locking the right things early and keeping everything else movable.

Sources

Tags

  • #scoping
  • #fixed-price
  • #architecture
  • #stakeholders
  • #delivery