What you'll be able to do
- Choose an engagement and pricing model, and say who carries the estimation risk under each
- Build a deliverable-oriented WBS and test it against an RFP with the 100% rule
- Estimate effort by role, price it from a rate card, and reconcile it with a month-by-month resource plan
- Derive contingency from three-point estimates instead of adding a percentage
- Plan discovery as a day-by-role activity grid with outcomes agreed with the client
- Write a transition plan: cutover, go/no-go and rollback criteria, hypercare and handover to support
Engagement models
The engagement model is not commercial trivia — it determines what you are allowed to assume about team stability, scope change and who carries the risk of being wrong. Time pressure during pre-sales often forces a shortcut Ian Gorton (Essential Software Architecture) calls a marketecture — a one-page, informal depiction of a system's structure and interactions, with just enough labels and boxes to convey the design philosophy behind it. It is not a lesser form of architecture work; it is a discussion vehicle for stakeholders during design, build, review and the sales process itself, and a legitimate starting point for the deeper analysis that follows once the engagement is won. The spectrum, roughly in order of how much the supplier owns:
| Model | Description | Architectural consequence |
|---|---|---|
| Project-based / defined scope | The supplier delivers an agreed scope. Reduces cost and time to market by buying expertise and capacity you do not have | Weakens badly when requirements evolve, or when the relationship will outlast one project. Pushes toward up-front design because change is expensive to transact |
| Dedicated team (often an offshore or nearshore development centre) | The client drives requirements; the supplier manages staffing, retention and ramp-up. Accommodates variety — new development, legacy modernisation, maintenance, testing | Team continuity makes incremental architecture viable. You can defer decisions because the people who made them are still there |
| Managed product development | The supplier owns end-to-end delivery: product management, architecture, implementation, operations and support | The architect owns outcomes rather than documents. Operational qualities — observability, deployability — stop being someone else's problem |
| Platform partnership | The supplier operates a platform on a continuing basis rather than delivering a project | Design for continuous change is the whole job. Total cost of ownership dominates build cost in every decision |
Two practical notes. The pricing model is often implied by the engagement model — staff augmentation tends to time-and-materials, defined scope tends to fixed price — and each puts the risk of estimation error on a different party. And architects are rarely involved in contract negotiation, which is usually owned by sales, account and delivery management; but you should know which model you are working under, because it silently sets the design constraints above.
| Pricing model | Who carries the estimation risk | What the estimate must give the commercial team |
|---|---|---|
| Time and materials (T&M) | The client | Rates, a resource plan and a forecast the client can track spend against |
| Capped T&M | Shared: the client pays actuals up to the cap, the supplier absorbs anything above it | A cap set from a stated percentile of the estimate, and change control for new scope |
| Fixed price | The supplier | A scoped WBS, assumptions and exclusions, contingency inside the price, and change control for anything outside the scope |
| Managed service / subscription | The supplier, for the length of the contract | Run cost and support staffing over the term, service levels, and how the fee moves with volume |
Before an engagement model is even chosen, the client's procurement process usually runs through a named sequence: a Request for Information (RFI) gathers background on candidate vendors, ahead of an RFP or RFQ; a Request for Quotation (RFQ) is used when the specification is already fixed and price is the deciding factor, skipping the back-and-forth an RFP requires; and a Request for Proposal (RFP) — the most formal of the three, with strict rules on content, timeline and vendor response — asks for a proposed solution to a stated problem. Which of these you are responding to changes how much solution detail, WBS and estimate an architect is expected to produce at that stage.
Applied to Lumen. The RFP asks for a platform delivered as a service, hosted and supported by the Supplier — the managed-product end of the table, so run and support are in scope, not an optional extra. That splits the offer in two. Price the build as a fixed price, or as capped T&M if discovery leaves the scope open, with contingency derived from the estimate rather than guessed. Price run and support — hosting, monitoring, incident response, upgrades to supported versions and a fixed capacity for small changes — as a monthly subscription with service levels. The evaluation shows why the second part matters as much as the first: total cost over five years carries 25% of the score, and build cost carries no weight of its own. Over five years the subscription costs more than the build, so a design that lowers run cost can win more cost points than a cheaper build (worked answer).
Estimation: art and science
| Character | |
|---|---|
| Science of estimation | Very mathematically intensive and can be quite accurate. Gives you theoretical numbers. Best implemented by software tools |
| Art of estimation | Involves heuristics and rules of thumb. Gives you practical help on real projects. Works best when supported by the estimation science |
The common idea is that an estimate is a prediction of the project outcome.
Tom DeMarco (Controlling Software Projects, 1982) additionally introduces a quality — or accuracy — attribute of the estimate. According to him the default definition among professionals is "the most optimistic prediction that has a non-zero probability of coming true". He argues a better definition is "a prediction that is equally likely to be above or below the actual result."
Over- vs underestimation
100% accurate estimates are very rare, so if we are going to err, is it better to err on the side of overestimation or underestimation? Steve McConnell's answer (Software Estimation: Demystifying the Black Art, 2006) is that the penalties are asymmetric:
| Direction | Penalty | Why |
|---|---|---|
| Underestimation | Nonlinear and unbounded | Planning errors, shortchanging upstream activities, and the creation of more defects cause more damage than overestimation does |
| Overestimation | Linear and bounded | Parkinson's Law and Student Syndrome. Work will expand to fill available time, but it will not expand any further |
- Parkinson's Law — "work expands so as to fill the time available for its completion". If you give a project team 6 months to complete a project that could be completed in 4, the team will find a way to use up the extra 2 months
- Student Syndrome — if developers are given too much time they'll procrastinate until late in the project, at which point they'll rush to complete their work, and they probably won't finish on time
In practice, significant overestimation can still produce an underestimation-like effect, because the spare time invites scope to grow. The "bounded" penalty holds only for modest overestimates.
Accuracy vs precision
Precision is independent of accuracy. People make assumptions about accuracy based on precision, so the precision you use should match the accuracy of your estimates.
A good analogy: imagine a basketball player shooting baskets. If the player shoots with accuracy, their aim will always take the ball close to or into the basket. If the player shoots with precision, their aim will always take the ball to the same location, which may or may not be close to the basket. A good player will be both accurate and precise — shooting the ball the same way each time and each time making it in the basket.
Inputs, outputs, and the sources of uncertainty
Input information consists of information about the project being estimated and about the capabilities of the organization that will be implementing and delivering it.
- Project data includes requirements both functional and non-functional, priorities (e.g. quicker is better) and constraints (e.g. the technology stack is already defined)
- Organizational influences include data about the organization's processes and the personnel's experience and skills
Output consists of estimated scope, effort, schedule and cost.
The estimation procedure itself has to be unbiased and should produce the same output on the same input data. If the outcome is unacceptable, negotiate the project — scope, staffing, dates — never the estimate: change the inputs only when the project itself changes, then re-run the same procedure.
There are two main sources of estimation uncertainty: incomplete or inaccurate input data, and inaccuracies of the estimation process itself.
| Cause | Effect |
|---|---|
| Omitted functional and especially non-functional requirements | Errors in project size estimation |
| Wrong assumptions about personnel's skills and performance | Errors in both effort and schedule estimation |
| Forgotten activities such as requirement analysis | Errors in effort estimation |
| Insufficient experience in the particular business area | Errors in project size estimation |
| Unfamiliar technologies | Wrong assumptions about performance, and thus errors in effort estimation |
The cone of uncertainty
Software development is a process of gradual refinement. You start with a general product concept — the vision of the software you intend to build — and refine that concept based on the product and project goals. Uncertainty in a software estimate results from uncertainty in how the decisions will be resolved; as you make a greater percentage of those decisions, you reduce the estimation uncertainty.
- The cone represents the best-case accuracy that is possible to have in software estimates at different points in a project
- The cone doesn't narrow itself. It narrows through project control. If the project is not well controlled, the cone of uncertainty becomes a cloud of uncertainty
- The schedule variability is much lower than the effort variability, because schedule is calculated as a cube-root function of effort for large projects
McConnell (Software Estimation, 2006) quantifies the cone as the best-case range, relative to the eventual actual, of effort and size estimates at each milestone:
| Milestone | Estimate range |
|---|---|
| Initial concept | 0.25× – 4× |
| Approved product definition | 0.5× – 2× |
| Requirements complete | 0.67× – 1.5× |
| User interface design complete | 0.8× – 1.25× |
| Detailed design complete | 0.9× – 1.1× |
Expressing probability
The curve of a probability distribution describes the probability associated with different estimate values; the height of the curve at each point is a probability density — how likely outcomes near that date or cost are — not the probability of finishing exactly on that date or costing exactly that much. What you usually want is the probability of delivering on or before a particular date, or at or below a specific cost or effort.
You can express probabilities in numerous ways:
- A "percent confident" attached to a single-point number — "we're 90% confident in the 24-week schedule"
- Best case and worst case, which implies a probability — "we estimate a best case of 18 weeks and a worst case of 24 weeks"
- A range rather than a single-point number — "we're estimating 18 to 24 weeks"
- A plus-or-minus qualifier — "6 months, ±1 month"
- A confidence factor — "there is 80% probability we can deliver by the end of Q4"
The key point is that all estimates include a probability, whether the probability is stated or implied. An explicitly stated probability is one sign of a good estimate.
An essential practice in presenting an estimate is to document the assumptions embodied in it. Then, if the project unfolds in a way that invalidates the assumptions, you can point back to the estimate assumptions as a basis for revising the estimate. The way you communicate an estimate suggests how accurate it is — if your presentation style implies an unfounded accuracy, you lay the groundwork for a difficult discussion about the estimate itself.
Work Breakdown Structure
There are broadly two approaches to WBS breakdown, plus mixed:
| Type | Definition |
|---|---|
| Deliverable-oriented (product WBS) | A hierarchical structure of things that the project will make, or outcomes that it will deliver. It's a classification of the project scope |
| Task-oriented | A hierarchical structure of tasks that, when completed, will result in satisfaction of all project commitments. It's an exhaustive list of work |
Questions to work through before you build your own WBS:
- What are the benefits of the deliverable-oriented WBS? Of the task-oriented WBS?
- What WBS is potentially more accurate?
- What WBS leads to easier change of the overall estimate and schedule?
A concrete case to reason about: you need to estimate Reporting, where you will need to build a core reporting framework plus a set of concrete reports. A natural mixed breakdown: Reporting is a deliverable; beneath it, build the core reporting framework is a task, while each concrete report is again a deliverable. Notice which parts can be added, removed or re-estimated one at a time, and which part every report depends on.
The 100% rule
PMI's Practice Standard for Work Breakdown Structures calls the WBS's governing constraint the 100% rule: the WBS includes all of the work the scope defines — external, internal and interim deliverables, project management included — and nothing outside it. The rule applies at every level: the children of an element add up to 100% of their parent, no more and no less. Work missing from the WBS is missing from the estimate, the resource plan and the price.
Check it in both directions:
- Forwards — walk the RFP line by line and map each requirement to a WBS element. A requirement with no element is an omission
- Backwards — walk the WBS and map each element to a requirement or to a stated assumption. An element with neither is gold-plating, or an assumption you have not written down
The forward check matters most when the WBS was built from a component list — services, portals, integrations — because components hide the requirements that cut across them, such as alerts, manual fallbacks and reports.
Estimation techniques
Decomposition is the practice of separating an estimate into multiple pieces, estimating each piece individually, then recombining the individual estimates into an aggregate. Also known as "bottom up" estimation.
Decomposition takes advantage of The Law of Large Numbers: if you create one big estimate, the estimate's error tendency will be completely on the high side or completely on the low side. But if you create several smaller estimates, some errors will be on the high side and some on the low side — the errors will tend to cancel each other out to some degree.
A related, formula-based technique for a single estimate is three-point (PERT) estimation: instead of one number, the estimator states a best case (a), most likely case (m) and worst case (b), which are combined into a weighted estimate — the standard PERT weighting is (a + 4m + b) ÷ 6. It pairs naturally with decomposition, since each decomposed piece can itself be given a three-point estimate before the pieces are recombined; Three-point estimates and contingency below shows how.
The four main steps of the estimation process: preparation → estimation of the development efforts → estimation of other activities → finalization.
It is important to estimate non-development activities. Examples: DevOps, business analysis, quality assurance, documentation. You can involve QA, BA and other specialists to help estimate them, or estimate them as a percentage of development efforts.
Conclude by creating the baseline schedule based on your estimated total. You can optionally check your total by using another estimation method.
Always agree what exactly you include in the "Development" activity — the idea is always to be on the same page, because development can include or not include unit testing, integration testing, dev documentation, architectural design, deploy, and so on.
Wideband Delphi
The steps below follow McConnell's description in Software Estimation; the method itself was developed by Barry Boehm and colleagues at the Rand Corporation in the 1970s as a variant of the Delphi technique.
- The Delphi coordinator presents each estimator with the specification and an estimation form
- Estimators prepare initial estimates individually. Optionally this step can be performed after step 3
- The coordinator calls a group meeting in which the estimators discuss estimation issues related to the project at hand. If the group agrees on a single estimate without much discussion, the coordinator assigns someone to play devil's advocate
- Estimators give their individual estimates to the coordinator anonymously
- The coordinator prepares a summary of the estimates on an iteration form and presents it to the estimators so they can see how their estimates compare with others'
- The coordinator has estimators meet to discuss variations in their estimates
- Estimators vote anonymously on whether they want to accept the average estimate. If any of the estimators votes "no", they return to step 3
- The final estimate is the single-point estimate stemming from the Delphi exercise. Or, the final estimate is the range created through the Delphi discussion, and the single-point Delphi estimate is the expected case
Estimation by analogy
The idea is simple: you create estimates for a new project by comparing the new project to a similar past project.
- Normally works well for teams and clients working in a concrete domain and/or with limited technologies and platforms — e-commerce, insurance
- It is important to use the actual results of the old project and not the old project estimates
- Can give quick results if you can find a similar project to compare to
- But the accuracy quickly decreases as the number and magnitude of differences between the projects grows
Story points and #NoEstimates
Approaches to story points: known velocity; defining a transformation coefficient — bad practice; trying to guess velocity; using ideal days and a focus factor.
An ideal person-day, per Henrik Kniberg (Scrum and XP from the Trenches), is "a perfectly effective, undisturbed day" — Mike Cohn's version of the same assumption (Agile Estimating and Planning) is that the story being estimated is the only thing worked on, everything needed is on hand, and there are no interruptions. Because no real day is ideal, you convert ideal person-days into calendar effort by dividing by a focus factor: calendar effort = ideal person-days ÷ focus factor. With a commonly used default of 0.75, 30 ideal person-days become 40 calendar person-days; the right value is team- and project-specific. (Early XP literature expresses the same idea as a load factor greater than 1 that you multiply by.)
The #NoEstimates movement explores alternatives for estimation.
Two rules behind every estimation technique
- All estimation techniques are based on previous experience. Model-based techniques use industry-average data; proxy-based (learn-oriented) techniques use the organization's historical data; expertise-based techniques use personal previous experience
- Project scope has to be defined as clearly as possible
McConnell's rule for any estimate: count if at all possible, compute when you can't count, and use judgement alone (e.g. "I think the hall is 70% full") only as a last resort. Practise it on something concrete — the number of people in a hall, say — by asking clarifying questions first and then trying several approaches.
Three-point estimates and contingency
Three-point estimating comes from PERT, developed for the US Navy's Polaris programme in the late 1950s. Three numbers per task are only useful if you combine them correctly. For each task:
- mean = (a + 4m + b) ÷ 6
- standard deviation σ = (b − a) ÷ 6
To total a set of tasks, add the means, and add the variances (σ²), never the standard deviations: σ_total = √(σ₁² + σ₂² + … + σₙ²). This holds for independent tasks, and it is the Law of Large Numbers again — overruns on some tasks are partly offset by underruns on others. Adding standard deviations, or adding worst cases, assumes every task goes wrong at once; the result is not a contingency but a price nobody will accept.
With a few dozen tasks the total is close to a normal distribution, so you can read off a percentile: P50 ≈ the total mean; P80 = mean + 0.84 σ_total; P90 = mean + 1.28 σ_total. Contingency is the gap between the percentile you commit to and the sum of the most-likely estimates. That makes it derived rather than guessed: you can defend it, and re-run it when the inputs change.
Two cautions. Dividing by 6 assumes a and b are true extremes; most estimators' ranges are narrower, so σ comes out too small, and McConnell (Software Estimation) recommends a smaller divisor when your past ranges have caught fewer actual outcomes. And tasks that share a cause — two integrations that depend on the same undocumented feed — are not independent: their spreads add almost linearly, so manage them in the risk register rather than trusting √Σσ².
Schedule compression
If there is a business need to compress your schedule, keep in mind that shorter schedules require more effort for several reasons:
- Larger teams require more coordination and management overhead
- Larger teams introduce more communication paths, which introduce more chances to miscommunicate, which introduce more errors, which then have to be corrected
- Shorter schedules require more work to be done in parallel. The more work that overlaps, the higher the chance both that one piece of work will be based on another incomplete or defective piece, and that later changes will increase the amount of rework
There is also a limit to how much you can compress your baseline schedule.
From estimate to resource plan
An estimate becomes a plan only when it is split by role, priced and staffed. The ground rules below are what make those three steps possible.
Ground rules that separate an estimate from a guess
- State what is included in the development line — core development, unit tests, integration tests, documentation — and what is not — business analysis, support, training, which you either estimate separately or exclude explicitly
- Separate by category — front end, back end, data, operations. This separation is what makes a resource plan possible at all
- Decide deliberately whether architecture effort sits inside development or is estimated as its own line
- Discovery and transition belong in the plan. If your estimate excludes them, say so explicitly rather than letting the omission pass silently
- Non-development work — management, business analysis, QA — is commonly estimated as a percentage: of development effort for QA and business analysis, of total team effort for management. That is defensible only if you state the percentage, its base, and why
- Price from a stated rate card. Days per role × day rate per role gives the cost. That step is only possible because the estimate was separated by category in the first place — which is why that ground rule is not bookkeeping
- Every number must reconcile with the resource plan. Roll the WBS up per role, book the same roles month by month, and compare: the totals, and each role, should agree within about ±5%. If development totals 100 person-days, roughly 100 days of development roles must appear in the plan. A total that does not reconcile is a total nobody checked
- Assumptions and exclusions are part of the estimate. Label every number the client did not give you, and list what the price does not cover
- For the discovery phase, produce an activity grid — days across, sessions down, each cell naming the activity and who must attend
The percentage rules, and why they are a judgement
| Rule | Typical range | What moves it |
|---|---|---|
| QA effort as a share of development | 20–60% | A system with a hard performance SLA needs a performance specialist as well as functional testing, which is what pushes it toward the upper end. A straightforward CRUD portal sits near the lower end |
| Management as a share of total team effort | ~10% | Team count and number of parties to coordinate |
| Operations engineering | Spans the whole delivery | Not a phase. Environments, pipelines and observability are needed from the first sprint to the last |
Pick a figure, write down the reasoning, and defend it in review. A ratio quoted without reasoning is the most common way an estimate becomes indefensible under pressure.
Discovery
Discovery participants vary with actual needs: a core of major roles plus specialists brought in as required, and normally an account manager as coordinator. Responsibilities depend on the client and the project.
- The discovery approach should be defined and communicated to the client. For example: 6 weeks, two streams, with on-site and remote presence varying by week
- In order to get valuable deliverables, the team should define and communicate to the client the assumptions (e.g. schedule, availability of key stakeholders) and the technical prerequisites
- Prepare an on-site agenda in advance — days across, sessions down, each cell naming the activity and who must attend (the same activity grid the Task asks for)
- Important: define and confirm with the client a set of expected outcomes, for example:
- A report including key issues and recommendations, if this is brownfield
- A roadmap
- Solution design and estimate
QAW, or any of its lightweight versions, can be used at this stage — details in Module 3, Quality Attribute Workshops.
Construction
This section covers the different areas solution architects can be responsible for or involved in during a project implementation phase. Clients and projects are different, therefore SA activities at this stage vary.
To the common question of what an architect should do during implementation, the generic but real answer: we work for and together with our customers, so we as architects must do everything from our side to ensure that projects are completed on time and with the required quality.
In a typical agile project the architect is involved in:
- Initial design during the inception phase — the Initial Architecture Vision
- Estimations
- Up-front design for the next iterations/releases
- System redesign
- Design of new or complex functionality
Note: at project level, much of a solution architect's governance work is implementation governance — following the agreed practices, doing architecture and code review, writing useful documentation. The rest — a design authority, decision records, fitness functions, compliance with the principles — is solution-level governance, covered in Module 8. Enterprise-wide governance belongs to the EA framework.
A useful model here is Patrick Lencioni's three virtues of an ideal team player (The Ideal Team Player, 2016) — humble, hungry and smart, in his order, with humility the most important — which map unusually well onto architecture work:
| Quality | A team player who is… |
|---|---|
| Humble | Lacks excessive ego and is not concerned with their status; quick to point out contributions of others and slow to seek attention for themselves; puts the team over self; defines success collectively rather than individually |
| Hungry | Self-motivated and hard-working; always thinks about the next step and next opportunity to contribute; always looking for more to do, more to learn and more responsibility; never wants to be considered a person who avoids work or effort |
| People Smart | Has common sense about people; actively listens to others and stays engaged in conversations; asks good questions; has good judgement and intuition about the subtleties of group dynamics; understands the impact of their words and actions |
There are different approaches to the test pyramid; the one presented is just one of them.
Each layer up trades speed and count for realism — many fast unit tests at the base, a handful of slow manual passes at the top.
Transition
Transition is not one activity but three handoffs, each with its own audience and its own failure mode if skipped:
- To production — the system goes live for its users. Construction ends with a stabilisation window before it: a code freeze admitting only critical fixes, user-acceptance and performance testing, and training material for end users. UAT is the exit evidence from that window, not the transition itself
- To another team or vendor — technical knowledge transfer, plus a review of the architecture, documentation, processes and UX
- To support and maintenance — knowledge transfer, and a review and update of the documentation
Treating transition as one generic wrap-up phase is how architects under-plan it. A go-live plan needs six things, agreed with the client before the date is fixed:
| Element | What it contains | Lumen example |
|---|---|---|
| Cutover plan | A timed runbook from code freeze to "open to users": an owner and a duration for each step, the point of no return, and at least one full dress rehearsal | Per region: load centre, partner and user master data and in-flight bookings; move that region's referrals from the desk to the platform; book one appointment end to end; open the portals |
| Go/no-go criteria | Measurable conditions, agreed in advance, and who decides | No open severity-1 or severity-2 defects; QA02's 2-second p95 met under a 1,680-referral busiest hour; 100% of in-flight bookings reconciled; the region's desk staff trained; the support rota staffed; rollback rehearsed. Lumen's sponsor decides on the supplier's recommendation |
| Operational readiness | The service can be run on day one: monitoring and alerts, runbooks, an on-call rota, service-desk routing, a restore from backup that has actually been tested, support access | Alerts on referral-sync lag (QA11) and on failed notifications, not only on servers |
| Rollback criteria | The triggers for going back and how far back is possible, decided before cutover | Before the point of no return, revert the region to the manual desk process if the booking path is down for 30 minutes in operating hours or any confirmed booking is lost or duplicated. After it, bookings exist only in the platform, so the remedy is to fix forward |
| Hypercare and warranty | Hypercare: a short period of heightened support, with the build team on hand and daily defect triage. Warranty: a contractual period in which defects in delivered scope are fixed at the supplier's cost | Two weeks of hypercare per region; 90 days of warranty from each regional go-live (assumption) |
| Knowledge transfer to run and support | Shadowing, then reverse shadowing; the architecture document, ADRs and runbooks reviewed by the receiving team; an exit test in which the support team resolves incidents unaided | The run team shadows hypercare in Regions 1–3 and leads it in Region 4 |
Rollback is not free, which is why the go/no-go bar is high. Assuming the four regions are of equal size, a region falling back to the desk for a day puts about 14,000 ÷ 4 = 3,500 referrals through manual handling at $7 each — roughly $24,500, a quarter of Lumen's $100,000 annual outage tolerance.
APM and TCO
APM (Application Performance Monitoring) follows requests through the solution — front end, services, data stores and external calls — to show where the time goes, which is how the sizing assumptions made in Module 9 get checked against production.
TCO — as solution architects we must understand what TCO means and why the business cares. It is life-cycle cost analysis, not merely build cost, and the dominant term is maintenance. Calculating a TCO figure rather than gesturing at one means defining the scope and length of ownership, building a cost model as a matrix of resources against cost type, and summing three categories per resource: acquisition cost (license, hardware, training, initial development), operating cost (keeping the resource running — updates, support, training) and change cost (enhancements and bug fixes). That structure is what lets an architect justify a design decision in cost terms instead of opinion. Module 9's worked cloud cost model builds the infrastructure part of that matrix for Lumen; the Task in this module adds the build and the support team to make the five-year view Lumen will score.
How much of a system's lifetime cost is maintenance? Software engineering literature has put it at roughly 60–80% of total lifetime cost for decades, and studies vary mainly in how they draw the boundary. The corollary for an architect is uncomfortable: most of the money is spent after you have gone, and a large share of it is spent working around decisions made early.
The classic decomposition comes from Lientz and Swanson (Software Maintenance Management, 1980) — corrective, adaptive and perfective maintenance — with preventive added later by ISO/IEC 14764 (2006 edition; since revised as ISO/IEC/IEEE 14764:2022). The 2006 standard groups corrective and preventive work as corrections, and adaptive and perfective work as enhancements. In Lientz and Swanson's data, perfective maintenance includes user-requested enhancements, which is why it dominates. Typical shares, which vary by study but not in their ordering:
| Maintenance type | What it is | Rough share |
|---|---|---|
| Corrective | Fixing defects found after deployment | ~20% |
| Preventive | Detecting and correcting latent faults before they cause failures | ~5% or less |
| Adaptive | Changing the system so it stays effective as its environment changes | ~25% |
| Perfective | New user-requested capability, plus improving performance, maintainability or documentation | ~50% or more |
Read that table next to the Module 3 modifiability material and the conclusion is uncomfortable but useful: the majority of what you will spend on a system after release is not fixing it — it is changing it. Which is precisely why binding time, cohesion and coupling decisions dominate TCO, and why "we'll make it flexible later" is the expensive option.
Check yourself
- A colleague prices a build by adding up every task's worst case "to be safe". What is wrong with that, and what would you do instead?
- Why does the sum of most-likely estimates usually come out below the actual effort, even when every estimator is honest?
- Your WBS rolls up to 2,400 person-days and your resource plan books 2,150. What does that tell you, and what do you change?
- How do you test a WBS against the 100% rule, and what does each direction of the check catch?
- Lumen weights five-year total cost at 25% and gives build price no separate weight. Why could a supplier with a higher build price still score better on cost?
- Under fixed price and under capped T&M, who carries the estimation risk, and how does that change what goes into the price?
- What makes a go/no-go criterion usable on the night of a cutover, and why must rollback criteria be agreed before it?
- Why plan discovery as a day-by-role grid rather than "four weeks of workshops"?
Suggested answers
- Adding worst cases assumes every task goes wrong at once, which almost never happens, so the result prices you out of the bid. Estimate three points per task, add the means and the variances, and commit to a stated percentile such as P80 = mean + 0.84σ.
- Task outcomes are skewed: the worst case lies further from the most likely than the best case does, so each task's mean is above its most-likely value. Summing most-likely values throws that skew away; in the Lumen worked answer it accounts for most of the contingency.
- The plan is about 10% short of the estimate, outside ±5%, so it cannot deliver the work as staffed. Reconcile per role to find where the gap is, then add people or months, or reduce scope — never quietly trim the estimate to fit.
- Forwards, map every requirement in the RFP to a WBS element; that catches omissions. Backwards, map every element to a requirement or a stated assumption; that catches gold-plating and unwritten assumptions. Management, discovery and transition must appear too.
- Because build is only part of five-year cost; run and support usually cost more over five years. A design and support model with lower run cost can outscore a cheaper build on the 25% weight.
- Under fixed price the supplier carries it, so the contingency, assumptions, exclusions and change control must all be in the price. Under capped T&M the client pays actuals up to a cap set from a stated percentile, and the supplier carries only what lies above the cap.
- It is measurable, owned and agreed in advance — "no open severity-1 defects", not "stable enough". Under cutover pressure people argue themselves past problems; pre-agreed rollback triggers and a known point of no return remove the debate.
- The grid tells the client which of its people must be in which room and when — stakeholder availability is a discovery assumption — and it makes the supplier's staffing, cost and expected outcome of each session explicit.
Exercises — Module 7
Task. Plan delivery for Lumen Diagnostics. Output: a delivery plan of 4–6 pages, mostly tables: a deliverable-oriented WBS with person-days per role and a 100% check against the case; the estimate with stated day rates and the resulting build cost; a month-by-month resource plan over the 12 months, phased by region; the reconciliation between WBS and resource plan; contingency derived from three-point estimates; a discovery plan with at least one week as a day-by-role grid; and a five-year cost view whose run-cost line comes from your Module 9 Task. Time: about 5–6 hours. Inputs: the case, especially Appendix B (timeline, phasing, evaluation weights); your Module 3 quality attribute scenarios, which set the testing effort; your Module 4 style choice and Module 5 container diagram, which set the components the WBS has to build. Module 9 comes later in the course: until you have done its Task, use the figure from its worked cloud cost model as a labelled placeholder.
- Read the Lumen Diagnostics case, including Appendix B
- Create a WBS (delivery-based, task-based, or mixed)
- Mixed WBSs are easy to get wrong; keep the two kinds distinct
- Run the 100% check in both directions and record the result
- Estimate effort per deliverable and role, split by category
- Split: front end / back end / data / operations
- In the development line: core development, unit tests, integration tests, documentation
- Outside the development line: business analysis, support, training (estimate them separately or exclude them explicitly)
- Say whether architecture effort sits inside development
- Discovery and Transition: in the plan, or explicitly excluded
- Non-development (management, BA, QA) as a stated percentage is fine — state its base (development or total team effort)
- Apply a rate card, stated as an assumption, to get the build cost
- Resource plan for all main roles, month by month, phased by region
- Reconcile the WBS roll-up with the resource plan, per role and in total
- Contingency from three-point estimates: means and variances summed, the percentile you commit to stated
- Assumptions, exclusions and risks
- Five-year cost view: build, run and support team, and the Module 9 run-cost line; say what it means for the 25% cost weighting
- Discovery plan (a day-by-role grid, not a slogan)
- Timeline
- Activities and roles (who attends QAW, playbacks, integration workshops)
- Who does what, day by role
- Expected outcomes
- At least one week in detail
Self-assessment
| Criterion | What good looks like |
|---|---|
| WBS passes the 100% rule | Every requirement area in the case maps to a WBS element, and every element maps to a requirement or a stated assumption. Management, discovery and transition are in it |
| Roll-up equals resource plan ±5% | The WBS roll-up and the resource plan agree within 5% in total and for each role, and the remaining differences are explained |
| Assumptions and exclusions listed | Every number the case does not give is labelled as an assumption; exclusions are stated, each with the clarification question that would settle it |
| Contingency derived, not guessed | Three-point estimates per deliverable, means and variances summed, and the percentile you price at stated with its probability |
| Discovery grid covers ≥5 days × roles | At least five days, each session naming the activity, the client attendees and which of your roles lead or attend, with the outcomes agreed with the client |
| Five-year view drives a conclusion | Build, support and run cost shown separately, and at least one design or commercial decision drawn from which line dominates |
Worked answer — a sample Lumen estimate
Attempt the Task before reading this. What follows is one supplier's answer. Your numbers will differ; what should match is that every number traces to a rule, a requirement or a labelled assumption, and that the totals reconcile.
Assumptions and exclusions
| # | Assumption |
|---|---|
| A1 | Effort is in planned person-days: estimators' ideal days are already divided by a focus factor of 0.75 |
| A2 | 20 working days a month per full-time person, 240 a year |
| A3 | Development means core development, unit and integration tests, and developer documentation. Data engineering sits in the back-end column — a simplification a larger bid would split out. Architecture is its own line, not inside development |
| A4 | QA and BA are estimated per deliverable, then checked against the percentage rules. QA is 403 ÷ 1,091 development days = 37%, toward the upper middle of the 20–60% band because of QA02's 2-second p95 target, two external integrations and residency testing. BA is 199 ÷ 1,091 = 18%. Management is 10% of all other roles' effort |
| A5 | Lumen's own 180 centres publish availability as a bulk feed through the same slot interface partners use (clarification question 1) |
| A6 | Production runs as four regional stacks from one set of infrastructure code, as Module 9's cost model prices it; regions go live one a month |
| A7 | There is no legacy booking system to migrate. Lumen supplies master data (centres, partners, users) and each region's in-flight bookings in an agreed template |
| A8 | Lumen runs UAT and trains its 350 desk staff, 900 centre staff and 1,500 partner users; the supplier trains Lumen's trainers |
| A9 | The day rates below are illustrative supplier rates, not market data |
| # | Exclusion |
|---|---|
| E1 | Passing the Billed stage to Lumen's finance system — not in the RFP's integration list (clarification question 2); priced as a change if required |
| E2 | The two future regions, including the one in a new jurisdiction |
| E3 | Run and support after month 12 — priced separately as a subscription |
| E4 | A standby disaster-recovery region beyond tested backup and restore — designed in the Module 9 Task, priced once that design is settled |
| E5 | Cloud charges for build-phase environments, passed through at cost |
Work breakdown structure
Deliverable-oriented, built from the case's requirement list rather than from a component list. m is the most-likely total for the row; a and b are the estimators' best and worst cases for the same row. Rows marked † are the ones a first cut built from the components — services, portals, integrations — misses; the 100% check below is what finds them.
| # | Deliverable | SA | BA | UX | FE | BE | QA | DevOps | PM | Total (m) | Best (a) | Worst (b) |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | Discovery | |||||||||||
| 1.1 | Discovery: architecture document, QA scenarios, refined WBS and plan, roadmap | 20 | 20 | 15 | 5 | 2 | 3 | 65 | 65 | 65 | ||
| 2 | Foundations | |||||||||||
| 2.1 | Environments, delivery pipeline, infrastructure as code, observability baseline | 5 | 10 | 3 | 40 | 58 | 50 | 75 | ||||
| 2.2 | Security and health-data compliance baseline: access roles, audit trail, encryption, regional data controls | 8 | 5 | 20 | 8 | 10 | 51 | 45 | 80 | |||
| 2.3 | Architecture and design through the build: ADRs, data model, integration contracts, design reviews | 45 | 5 | 10 | 60 | 55 | 80 | |||||
| 3 | Platform capabilities | |||||||||||
| 3.1 | Referral synchronisation: 15-minute extract, new referrals, amendments, cancellations | 10 | 40 | 12 | 62 | 50 | 125 | |||||
| 3.2 | Conflict merge by policy, with alerts to affected parties † | 8 | 8 | 25 | 10 | 51 | 40 | 100 | ||||
| 3.3 | Availability search and prioritisation rules (including Lumen centre slots, A5) | 10 | 15 | 80 | 32 | 137 | 110 | 275 | ||||
| 3.4 | Configurable offer and confirmation workflow | 12 | 10 | 70 | 28 | 120 | 100 | 190 | ||||
| 3.5 | Email and SMS notification on stage change | 4 | 25 | 9 | 38 | 35 | 50 | |||||
| 3.6 | Referral-desk manual booking and reassignment † | 8 | 5 | 35 | 20 | 19 | 87 | 80 | 115 | |||
| 3.7 | Appointment consolidation † | 8 | 10 | 30 | 14 | 62 | 55 | 100 | ||||
| 3.8 | Preferred locations: load, amend, override | 3 | 8 | 10 | 6 | 27 | 25 | 35 | ||||
| 4 | Portals | |||||||||||
| 4.1 | Shared design system, responsive on phones and tablets | 30 | 45 | 10 | 85 | 75 | 110 | |||||
| 4.2 | Patient portal: appointments, confirm or decline, view and print confirmations | 8 | 15 | 65 | 30 | 33 | 151 | 130 | 240 | |||
| 4.3 | Patient feedback linked to the appointment † | 3 | 5 | 10 | 10 | 7 | 35 | 30 | 45 | |||
| 4.4 | Administration portal: configuration, appointment status | 12 | 15 | 75 | 40 | 40 | 182 | 155 | 290 | |||
| 4.5 | Partner portal: slot, pricing and capability upload; partner bookings | 8 | 10 | 55 | 40 | 33 | 146 | 125 | 235 | |||
| 5 | Integrations | |||||||||||
| 5.1 | Patient identity service | 3 | 20 | 7 | 30 | 25 | 50 | |||||
| 5.2 | Single sign-on: corporate SSO for staff, sign-in for patients | 5 | 20 | 8 | 3 | 36 | 30 | 45 | ||||
| 5.3 | Automated partner group scheduling API | 5 | 45 | 16 | 66 | 55 | 130 | |||||
| 6 | Reporting | |||||||||||
| 6.1 | Reporting data store and feed † | 30 | 10 | 5 | 45 | 40 | 70 | |||||
| 6.2 | Appointment-detail, partner-performance and financial reports † | 12 | 25 | 35 | 21 | 93 | 80 | 150 | ||||
| 7 | Non-functional testing | |||||||||||
| 7.1 | Performance, security and residency-compliance testing; backup and restore test | 5 | 10 | 45 | 10 | 70 | 60 | 110 | ||||
| 8 | Transition | |||||||||||
| 8.1 | Release readiness: production configuration, master data and in-flight bookings, runbooks, UAT support | 5 | 10 | 25 | 10 | 15 | 65 | 55 | 105 | |||
| 8.2 | Training materials and train-the-trainer | 25 | 5 | 30 | 25 | 40 | ||||||
| 8.3 | Regional rollout ×4: cutover and two weeks of hypercare each | 8 | 20 | 20 | 40 | 20 | 20 | 128 | 110 | 205 | ||
| 8.4 | Knowledge transfer to run and support | 5 | 5 | 10 | 10 | 30 | 25 | 40 | ||||
| 9 | Operations through delivery | |||||||||||
| 9.1 | Platform operations, months 2–12: environments, releases, monitoring | 150 | 150 | 150 | 150 | |||||||
| 10 | Management | |||||||||||
| 10.1 | Project management: 10% of all other roles (2,160 × 10%) | 216 | 216 | — | — | |||||||
| Roll-up per role | 101 | 199 | 100 | 391 | 700 | 403 | 266 | 216 | 2,376 | 1,880 | 3,305 |
Discovery (1.1) is time-boxed and platform operations (9.1) is level-of-effort, so both have a = m = b. Management is derived from the other rows, so the a and b totals leave it out.
The 100% check
Forwards, from the case to the WBS:
| Case requirement | WBS elements |
|---|---|
| Availability search and prioritisation, custom rules, amendments by the patient or the Scheduling Manager | 3.3, 4.2, 4.4 |
| Offer and confirmation workflow, changeable and extensible later | 3.4, 4.4 |
| Email and SMS notification on stage change | 3.5 |
| Manual booking by the referral desk; manual reassignment | 3.6 † |
| Frequent synchronisation with the referral management system | 3.1 |
| Conflicts merged by a defined policy, with alerts to affected parties | 3.2 † |
| Partner upload of slots, pricing and capability; manual partner booking | 4.5 |
| One automated partner group; preferred locations and overrides | 5.3, 3.8 |
| Appointment consolidation | 3.7 † |
| Patient portal, including single sign-on and printing | 4.2, 5.2 |
| Patient feedback associated with the appointment | 4.3 † |
| Administration portal: configuration, status visibility, reporting front end | 4.4, 6.2 |
| Appointment-detail, partner-performance and financial reporting | 6.1, 6.2 † |
| Referral system, patient identity service, corporate SSO | 3.1, 5.1, 5.2 |
| One look and feel; phones and tablets | 4.1 |
| Data platform, performance, scalability, high availability | 2.3, 6.1, 7.1, 9.1 |
| Configurable without code change | 3.3, 3.4, 4.4 |
| Configuration management and robust promotion to live | 2.1, 9.1 |
| TLS 1.3; health-data regulation in each region | 2.2, 7.1 |
| Hosted and supported by the supplier; supported technology versions | 2.1, 8.4, and the run and support subscription (E3) |
| First release within 12 months, phased by region | 8.1, 8.3, and the resource plan |
| Not in the requirement list but part of the work: discovery, training, management | 1.1, 8.2, 10.1 |
| Gaps in the RFP | A5 (centres' availability), E1 (finance) |
Backwards, every row in the WBS traces to a line above or to an assumption; nothing is in the WBS for its own sake.
Rate card and build cost
| Role | Day rate (assumption) | WBS days | Cost |
|---|---|---|---|
| Solution architect | $1,100 | 101 | $111,100 |
| Project manager | $950 | 216 | $205,200 |
| Business analyst | $800 | 199 | $159,200 |
| UX designer | $800 | 100 | $80,000 |
| Front-end developer | $750 | 391 | $293,250 |
| Back-end developer | $800 | 700 | $560,000 |
| QA engineer | $650 | 403 | $261,950 |
| DevOps engineer | $850 | 266 | $226,100 |
| Total | $798 blended | 2,376 | $1,896,800 |
Resource plan
Twelve months from contract signature. Region 1 cuts over at the end of month 8 — the first release, four months inside the 12-month deadline — and Regions 2, 3 and 4 follow one a month, each with two weeks of hypercare. The cells are person-days; 20 is one person full-time for the month.
| Role | M1 | M2 | M3 | M4 | M5 | M6 | M7 | M8 | M9 | M10 | M11 | M12 | Total |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Phase | Discovery | Foundations | Build | Build | Build | Build | Build | Harden, UAT | Region 1 live | Region 2 live | Region 3 live | Region 4 live, handover | |
| SA | 20 | 15 | 10 | 10 | 10 | 5 | 5 | 10 | 5 | 5 | 5 | 5 | 105 |
| BA | 20 | 20 | 20 | 20 | 20 | 20 | 20 | 20 | 15 | 10 | 10 | 5 | 200 |
| UX | 15 | 20 | 20 | 20 | 10 | 10 | 5 | 0 | 0 | 0 | 0 | 0 | 100 |
| Front end | 0 | 20 | 40 | 60 | 60 | 60 | 60 | 40 | 20 | 10 | 10 | 10 | 390 |
| Back end | 5 | 40 | 80 | 100 | 100 | 100 | 100 | 60 | 40 | 30 | 30 | 20 | 705 |
| QA | 2 | 10 | 30 | 40 | 50 | 50 | 60 | 60 | 40 | 25 | 20 | 20 | 407 |
| DevOps | 3 | 40 | 20 | 20 | 20 | 20 | 20 | 30 | 30 | 20 | 20 | 20 | 263 |
| PM | 10 | 20 | 20 | 20 | 20 | 20 | 20 | 20 | 20 | 20 | 20 | 10 | 220 |
| Person-days | 75 | 185 | 240 | 290 | 290 | 285 | 290 | 240 | 170 | 120 | 115 | 90 | 2,390 |
| Team (FTE) | 3.75 | 9.25 | 12 | 14.5 | 14.5 | 14.25 | 14.5 | 12 | 8.5 | 6 | 5.75 | 4.5 | 10 average |
Reconciliation
| Role | WBS roll-up | Resource plan | Difference |
|---|---|---|---|
| SA | 101 | 105 | +4 (+4.0%) |
| BA | 199 | 200 | +1 (+0.5%) |
| UX | 100 | 100 | 0 |
| Front end | 391 | 390 | −1 (−0.3%) |
| Back end | 700 | 705 | +5 (+0.7%) |
| QA | 403 | 407 | +4 (+1.0%) |
| DevOps | 266 | 263 | −3 (−1.1%) |
| PM | 216 | 220 | +4 (+1.9%) |
| Total | 2,376 | 2,390 | +14 (+0.6%) |
Within ±5% in total and for every role. Three things to read from it:
- Check per role, not only in total. A total can reconcile while back end is 20% short and QA 20% over — the plan would then fail on the back-end work it cannot staff
- Positive differences are booking granularity — people booked in quarter- and half-months. They are real cost: priced on the plan instead of the WBS, the build is $1,909,100, $12,300 more. Negative differences are work the plan cannot deliver; DevOps is 3 days short, small enough to absorb in month 12 here, but a negative difference is never ignored
- Check per phase as well. The M1 column — 20 SA, 20 BA, 15 UX, 5 back end, 2 QA and 3 DevOps days — is exactly WBS row 1.1, plus half-time management
Contingency from three-point estimates
Three of the riskiest deliverables first, using mean = (a + 4m + b) ÷ 6 and σ = (b − a) ÷ 6:
| Deliverable | a | m | b | Mean | σ | σ² |
|---|---|---|---|---|---|---|
| 3.1 Referral synchronisation | 50 | 62 | 125 | 70.5 | 12.5 | 156.25 |
| 3.3 Availability search and prioritisation | 110 | 137 | 275 | 155.5 | 27.5 | 756.25 |
| 5.3 Automated partner group API | 55 | 66 | 130 | 74.8 | 12.5 | 156.25 |
| Total | 265 | 530 | 300.8 | 1,068.75 |
- σ_total = √1,068.75 = 32.7 days
- P80 = 300.8 + 0.84 × 32.7 = 328 days, against 265 most likely — 63 days of contingency for these three
- Adding the σs instead (52.5) gives 300.8 + 0.84 × 52.5 = 345; adding the worst cases gives 530. Both describe all three going wrong at once
The same arithmetic over all 28 non-management rows (26 with a range) of the WBS:
- Sum of most-likely values: 2,160 days. Sum of means: 2,304.2
- Sum of variances: 3,367.4, so σ_total = √3,367.4 = 58.0
- P80 = 2,304.2 + 0.84 × 58.0 = 2,353 days
- Contingency = 2,353 − 2,160 = 193 days, plus 10% for management = 212 days, or 212 × $798 ≈ $169,200
Of the 193 days, 144 are the skew (2,304 − 2,160) and only 49 the spread (0.84 × 58.0): most of the contingency exists because each row's worst case is further from its most-likely value than its best case is. Adding the σs would have produced 344 days of contingency; adding the worst cases, a total of 3,305 days — 1,145 days (53%) over the most-likely total. Rows 3.1 and 3.2 share a cause — the referral extract's format and amendment rules — so they are not fully independent; that risk is carried in the register, and the extract samples requested in discovery week 1 are its mitigation. On schedule, 212 days is about three weeks of the peak team, and the first release has four months of float.
Price and the five-year view
Build price: a fixed price of $2,066,000 at P80 ($1,896,800 + $169,200), or capped T&M with a forecast of $1,896,800 and a cap of $2,066,000, if Lumen prefers to keep the unused contingency.
Run and support subscription, from month 13 (assumption: three FTE, 24×7 on-call shared with the supplier's managed-service rota):
| Role | FTE | Days a year | Cost a year |
|---|---|---|---|
| Service manager (PM rate) | 0.5 | 120 | $114,000 |
| Solution architect | 0.25 | 60 | $66,000 |
| Back-end developer | 1.0 | 240 | $192,000 |
| Front-end developer | 0.5 | 120 | $90,000 |
| QA engineer | 0.25 | 60 | $39,000 |
| DevOps / site reliability | 0.5 | 120 | $102,000 |
| Total | 3.0 | 720 | $603,000 |
The RFP does not say when its five years start; this view assumes the build plus five years of service, which matches Module 9's model (clarification question 3).
| Cost line | Basis | Five years |
|---|---|---|
| Build | Fixed price at P80 | $2.07M |
| Run and support team | $603,000 a year × 5, held flat (assumption) | $3.02M |
| Infrastructure and messaging | Module 9's worked cloud cost model: ≈ $19,360 a month at today's volumes, volume-driven lines growing 12% a year | ≈ $1.37M |
| Total | ≈ $6.45M |
The build is 32% of what Lumen will score on cost ($2.07M ÷ $6.45M); the support team is nearly half. SMS alone is about $0.96M of the run cost, nearly six times the build contingency, and it can only be cut by a requirement change Lumen agrees to. With cost weighted at 25%, the support model and the run cost are where this bid wins or loses its cost score — the TCO section's point that most of the money is spent after the build team has gone, in Lumen's own numbers.
Discovery plan
Four weeks, in month 1 of the resource plan:
| Week | Where | Focus | Output |
|---|---|---|---|
| 1 | Remote | Read the RFP, the referral-system extract specification and samples, identity, SSO and partner API documentation; stakeholder map; confirm the week-2 agenda and attendees | Review notes, stakeholder map, confirmed agenda |
| 2 | On site | Workshops — grid below | Goals, quality attribute scenarios, integration facts, journeys, open-questions log |
| 3 | Mixed | Integration deep dives on sample extracts; prototype search-rule and workflow configuration; journey tests with patients and partners | Draft integration contracts, prioritised utility tree, UX concepts |
| 4 | Remote, then on site | Architecture document; refined WBS, estimate and resource plan; roadmap and regional order; playback and sign-off | The agreed outcomes below |
Week 2 in detail. ● leads, ○ attends; the tech lead is the lead back-end developer.
| Day | Session | Activity | Lumen attendees | SA | BA | UX | Tech lead | QA | DevOps | PM |
|---|---|---|---|---|---|---|---|---|---|---|
| Mon | AM | Kick-off: business goals, drivers, success measures; confirm the discovery outcomes | Sponsor, operations director, scheduling manager | ● | ○ | ○ | ● | |||
| Mon | PM | Referral-desk walk-through and shadowing: phone and email booking today | Two desk team leads | ○ | ● | ● | ||||
| Tue | AM | Quality attribute workshop: goals to scenarios for availability, performance, modifiability, security | Operations director, IT architect, scheduling manager, finance (outage cost) | ● | ○ | ○ | ○ | ○ | ||
| Tue | PM | Quality attribute workshop: prioritise scenarios, draft the utility tree | As the morning | ● | ○ | ○ | ○ | |||
| Wed | AM | Integration: referral-system extract — format, amendments, cancellations, conflict policy | Referral-system owner, integration lead | ● | ○ | ● | ||||
| Wed | PM | Integration: identity service, SSO, partner group API; clarification questions on centre availability and the Billed stage | Identity owner, security officer, partner group IT contact, finance systems lead | ● | ○ | ● | ○ | |||
| Thu | AM | Workflow and rules: stages, notification policy (email and SMS), prioritisation and consolidation rules | Scheduling manager, clinical lead | ○ | ● | ○ | ○ | ○ | ||
| Thu | PM | Journeys: patient, partner and administrator; reporting needs | Patient-experience lead, two partner practice managers, finance analyst | ● | ● | |||||
| Fri | AM | Hosting, security and compliance: residency, encryption, audit, support model, service levels | Security officer, data protection officer, IT operations | ● | ○ | ○ | ○ | |||
| Fri | PM | Playback: findings, open questions, risks, plan for week 3 | Sponsor and every workshop owner | ● | ● | ○ | ○ | ● |
The grid agrees with WBS row 1.1: the tech lead spends 3.5 of their 5 discovery days in week 2, QA 1.5 of 2 and DevOps 1.5 of 3.
Discovery assumptions, agreed with Lumen in advance: a named sponsor and a day-to-day contact; the attendees above available for their sessions; sample extract files and identity-service documentation by the end of week 1; a room on site in week 2.
Expected outcomes, signed off at the end of week 4: the architecture document (application, data, integration and deployment views); prioritised quality attribute scenarios; the refined WBS, estimate, resource plan and assumptions register; the roadmap with the regional rollout order; and answers to the clarification questions.