Logic Model: the one-page programme summary that earns its keep

Inputs: funding, staff, partners, facilities — what the programme consumes. Activities: what it does with them. Outputs: direct, countable products — sessions run, people trained, materials distributed. Outcomes: changes in knowledge, behaviour, condition — usually split short/medium/long term. Impact: the population- or system-level change the programme exists for.

The most consequential line in the model is the output–outcome boundary. Everything left of it is under the programme’s control and will happen if the team shows up; everything right of it happens in other people’s lives and might not. Evaluations that report outputs as achievements are trading on the reader not noticing the line.

Good models also carry two margins the template often omits: external factors (what else moves the outcomes) and assumptions (why anyone believes the arrows) — the minimal imports from theory-of-change practice that keep the page honest.

The programme-evaluation formulation is anchored by McLaughlin and Jordan’s Logic models: a tool for telling your program’s performance story00042-1), which frames the model as the backbone for performance measurement and evaluation design.

The most widely used practitioner guide is the W.K. Kellogg Foundation’s Logic Model Development Guide (W.K. Kellogg Foundation), the source of the standard five-column template and the workshop practices most organisations imitate.

The format’s family resemblance to results chains and logframes is real: the logic model is the diagrammatic summary; the logframe is its management-matrix cousin with indicators and risks attached.

• Design triage: a draft model exposes programmes that are all activity and no outcome pathway in about an hour.
• Shared reference: boards, funders, implementers, and evaluators pointing at the same page — the coordination value is easy to underrate.
• Evaluation scaffolding: indicators mapped to columns, evaluation questions to arrows; the model is the cheapest way to make an M&E plan coherent.
• Not causal argument: the arrows summarise beliefs argued elsewhere (or not at all). Complex, adaptive, or contested programmes need a theory of change behind the page.
• Not a straitjacket: programmes that iterate weekly need living models; a laminated logic model governing an adaptive programme is managing last year.

A food-bank network drafted a logic model for its new “more than food” strategy. The first draft was symptomatic: activities (parcels, advice sessions, referrals) flowed to an impact of “reduced food insecurity”, with the outcome column filled by restated outputs — “clients receive advice” standing where a change should be.

Outcomes-first redrafting forced the real question: what change in whose situation? The revised column read “clients resolve the benefit or debt issue driving food-bank use (3 months)” and “repeat-visit rate falls among advised clients (12 months)” — outcomes the network had never measured. Indicators were attached (case resolution from advice-partner records; visit patterns from its own database), and “external factors” recorded what everyone knew and the old model hid: local benefit-processing delays moved demand more than anything the network did.

Twelve months later the versioned model told a useful story: advice uptake converted poorly from parcels alone (output→outcome arrow weak), tripling where advisers sat in the distribution centre (a delivery change the review triggered), while repeat-visit reduction tracked the external benefits backlog — reported as context, not claimed as impact. The one-pager had done its job: not proving causation, but making the programme’s claims, measures, and surprises legible on a single sheet.

• Outputs dressed as outcomes. “500 people trained” in the outcome column is the format’s signature abuse.
• Arrows as evidence. Reading the diagram’s left-to-right flow as demonstrated causation, then reporting accordingly.
• The immaculate model. No external factors, no assumptions — a programme operating in vacuum, on paper only.
• Everything models. Ten activities, thirty outcomes, all connected: a model that cannot discipline anything.
• One-and-done. Built for the funding bid, never revisited; the review-and-version step is what separates instrument from ornament.
• Impact claimed at output speed. Long-term impact rows reported in year one from short-term proxies, with the timeframe quietly dropped.

The format is linear and tidy; programmes are neither. Feedback loops, participant agency, and adaptive change fit the page badly, and complex interventions summarised into five columns lose exactly the dynamics that determine their success.

The model asserts sequence, not mechanism — why the arrows should hold is outside the format. Paired with a theory of change it summarises well; alone it can launder assumption into apparent plan.

And its legibility to funders creates its own incentive: models optimised to look fundable rather than to be true. The discipline against that is versioning against evidence, which no template supplies — only management practice does.

A theory of change supplies the argued causal pathway a logic model summarises — build it first for anything contested or complex.

The logical framework approach extends the same logic into a full management matrix with indicators, means of verification, and risks.

Process evaluation tests the model’s left half — whether activities and outputs happened as designed, for whom.

Outcome harvesting works backwards from observed changes when the forward logic could not have predicted them.

The model’s outcome columns run on evidence that is often qualitative — participant interviews, advice-session notes, partner reports — and connecting that material to specific outcomes is codebook work: Evidano codes it against the model’s outcome and assumption set, with quotes linked, so quarterly reviews read evidence per arrow instead of anecdotes per meeting. Open-ended feedback at output points (session forms, referral notes) aggregates the same way.

The modelling itself is a team’s thinking made compact; no tool should generate it, and a generated one would encode nobody’s actual commitments — which is the only thing a logic model has to offer.