Logic Models and Theory of Change: Frameworks for Causal Strategy and Evaluation

Last Updated June 8, 2026

Logic models and Theory of Change frameworks help teams explain how action is expected to produce results. They connect resources, activities, outputs, outcomes, assumptions, evidence, and long-term impact. A logic model usually shows the operational pathway from inputs to activities to outputs to outcomes. A Theory of Change explains the causal reasoning behind that pathway: why these actions should lead to those outcomes, under what conditions, and for whom.

Logic Models and Theory of Change Frameworks examines these frameworks as tools for program design, evaluation, content governance, research communication, policy explanation, education, nonprofit accountability, and strategic planning. The article explains how logic models and Theory of Change frameworks clarify assumptions, map evidence, define indicators, support evaluation, and communicate complex initiatives responsibly. Used well, they make strategy more testable. Used poorly, they turn uncertainty into a neat diagram that hides weak assumptions.

This article explains logic models and Theory of Change frameworks as tools for causal explanation, measurement, evaluation, and governance. It examines inputs, activities, outputs, outcomes, impacts, assumptions, indicators, evidence strength, review cycles, stakeholder value, ethical risks, and relationships to OKRs, KPIs, SWOT, policy explanation, systems thinking, content audits, and message architecture. It also includes computational workflows for auditing causal claims, evidence gaps, pathway completeness, and governance priorities.

Why Logic Models and Theory of Change Matter

Logic models and Theory of Change frameworks matter because many strategies depend on causal claims. A team may claim that a program will improve learning, that a policy will reduce harm, that a content system will increase public understanding, or that a platform will support better decisions. These claims should not remain implicit. They should be mapped, tested, explained, and governed.

A logic model helps organize the operational chain: what resources are available, what actions will be taken, what outputs will be produced, what outcomes are expected, and what long-term impact is intended. A Theory of Change goes deeper into the reasoning behind the chain. It asks why the pathway should work, what assumptions must hold, what evidence supports the linkages, and what external conditions may affect success.

For content frameworks, these models are useful because knowledge systems also make causal promises. An article map may claim to improve navigation. A companion repository may claim to improve reproducible learning. A framework series may claim to improve public reasoning. A governance workflow may claim to improve quality over time. Logic models and Theory of Change frameworks make those promises inspectable.

The value of these frameworks is not that they make change simple. Their value is that they make theories of action explicit enough to question, test, revise, and communicate responsibly.

Back to top ↑

What Logic Models Are

A logic model is a structured representation of how a program, project, strategy, or intervention is expected to work. It usually connects inputs, activities, outputs, outcomes, and impact. The model may be shown as a table, flow diagram, pathway map, or narrative sequence.

The basic logic is straightforward: if resources are available, activities can be carried out; if activities are carried out, outputs can be produced; if outputs reach the intended audience under the right conditions, outcomes may occur; if outcomes accumulate over time, longer-term impact may become possible.

A logic model should not merely list activities. It should show how activities are expected to produce outputs and how outputs are expected to contribute to outcomes. The distinction matters because many organizations measure what they produce while failing to examine what changes.

Back to top ↑

What Theory of Change Is

A Theory of Change is an explanation of how and why a desired change is expected to happen. It identifies the causal pathway, assumptions, preconditions, mechanisms, stakeholders, context, evidence, and risks. It may include a diagram, but the diagram is not the theory. The theory is the reasoning behind the pathway.

Theory of Change frameworks are especially useful when the desired change is complex, long-term, contested, or dependent on many actors. They help teams avoid assuming that activity automatically creates impact. Instead, they ask what must happen between action and outcome.

A strong Theory of Change is honest about uncertainty. It does not pretend that every link is proven. It distinguishes evidence-backed claims from hypotheses that need testing.

Back to top ↑

Logic Models vs Theory of Change

Logic models and Theory of Change frameworks are closely related, but they emphasize different things. A logic model often focuses on program structure and evaluation: resources, actions, outputs, outcomes, and impact. A Theory of Change focuses more on causal explanation: why those actions should produce those outcomes, what assumptions must hold, and what evidence supports the theory.

In practice, they work best together. The logic model gives operational structure. The Theory of Change gives causal reasoning. The measurement framework gives indicators and review cycles. Governance ensures that the model is updated when evidence changes.

The simplest distinction is this: a logic model shows the pathway; a Theory of Change explains why the pathway should work.

Back to top ↑

Inputs and Resources

Inputs are the resources needed to carry out the work. They may include funding, staff time, expertise, technology, datasets, research, community relationships, partnerships, editorial standards, infrastructure, tools, and governance systems. In a content-framework context, inputs also include article maps, taxonomy, metadata, internal links, source libraries, code repositories, templates, and review processes.

Inputs matter because strategy depends on capacity. A logic model that lists ambitious outcomes without sufficient resources is not credible. A Theory of Change that assumes capabilities that do not exist should be flagged for review.

Inputs should be realistic. If essential resources are missing, the model should show the gap rather than hide it.

Back to top ↑

Activities and Interventions

Activities are the actions taken with available resources. In a program, activities may include workshops, training, outreach, services, curriculum design, coaching, public engagement, technical assistance, or policy work. In a content system, activities may include writing articles, building article maps, producing companion code, auditing metadata, creating diagrams, improving internal links, updating references, or publishing governance reports.

Activities are necessary, but they are not outcomes. This distinction is one of the most important uses of logic models. Completing an activity does not prove that meaningful change occurred. It only shows that work was performed.

Activities should be specific enough to evaluate. “Improve communication” is not a useful activity. “Revise article introductions to clarify audience, scope, and series context” is more actionable.

Back to top ↑

Outputs

Outputs are the direct products of activities. They are usually countable: articles published, workshops delivered, datasets produced, repositories created, tools released, pages revised, reports completed, or participants reached. Outputs show that work happened. They do not automatically show that the work achieved its purpose.

Outputs are useful because they provide concrete evidence of implementation. However, output measurement becomes misleading when teams treat output volume as impact. Publishing more articles is not the same as improving knowledge access. Producing more dashboards is not the same as improving decisions. Running more workshops is not the same as improving skills.

Outputs should be connected to outcome indicators. Otherwise, the model may reward production without learning whether the work helped anyone.

Back to top ↑

Outcomes

Outcomes are changes that occur because of the work. They may involve knowledge, behavior, skill, trust, access, quality, decision-making, collaboration, organizational practice, or system performance. Outcomes are often divided into short-term, intermediate, and long-term outcomes.

Short-term outcomes may involve awareness, understanding, access, or initial adoption. Intermediate outcomes may involve behavior change, improved practice, better decisions, or stronger systems. Long-term outcomes may involve durable institutional change, public value, reduced harm, improved resilience, or sustained learning.

Outcomes are often harder to measure than outputs. That is why Theory of Change work matters: it explains why the outputs are expected to contribute to outcomes and what evidence would support that claim.

Back to top ↑

Impact and Long-Term Change

Impact refers to the broader long-term change that an initiative hopes to support. Impact may be social, educational, environmental, organizational, institutional, economic, civic, or cultural. Impact is often influenced by many factors beyond the program or content system itself, so impact claims require humility.

A logic model can identify intended impact, but it should not imply that the initiative alone will cause that impact. A Theory of Change can explain contribution: how the initiative may help create conditions for change, alongside other actors, systems, and contextual forces.

Impact language should distinguish direct control, influence, and contribution. Many initiatives contribute to change without controlling it.

Back to top ↑

Assumptions and Preconditions

Assumptions are beliefs that must hold for the pathway to work. Preconditions are conditions that must exist before an outcome can occur. Logic models often hide assumptions unless they are added explicitly. Theory of Change frameworks make assumptions central.

For example, a content system may assume that readers can find the article map, that the language is understandable, that the internal links support discovery, that companion code runs correctly, that metadata improves search visibility, or that audiences trust the source. If those assumptions fail, the pathway may break.

Assumptions should be reviewed, not merely listed. A weak assumption can become a high-priority governance item.

Back to top ↑

Causal Pathways and Evidence

A causal pathway connects actions to outcomes through intermediate steps. It should show how change is expected to happen, not only what the final result should be. Strong causal pathways include mechanisms, assumptions, evidence, and possible failure points.

Evidence may come from research literature, prior evaluations, user behavior, interviews, analytics, experiments, qualitative feedback, expert review, administrative data, or implementation records. The evidence does not need to be perfect, but it should be identified and graded honestly.

A causal pathway should show where the evidence is strong, where the evidence is weak, and where the model depends on assumptions that need testing.

Back to top ↑

Indicators, OKRs, KPIs, and Evaluation

Logic models and Theory of Change frameworks become more useful when connected to measurement. Outputs, outcomes, assumptions, and risks should have indicators. OKRs can define improvement priorities for a specific cycle. KPIs can monitor ongoing health and performance. Evaluation can examine whether the causal pathway is working.

The key is to measure the right layer. Outputs need output indicators. Outcomes need outcome indicators. Assumptions need assumption tests. Governance processes need review indicators. Impact claims need careful contribution evidence.

Measurement should not be attached only at the end. A well-governed framework tracks the whole pathway so teams can learn where change is succeeding or breaking down.

Back to top ↑

Practical Uses of Logic Models and Theory of Change

Logic models and Theory of Change frameworks can support program planning, evaluation, nonprofit accountability, public policy, education, research communication, grant proposals, organizational strategy, product development, content governance, and platform design. They are especially useful when a team needs to explain not only what it will do, but why those actions should matter.

The frameworks are strongest when they connect planning, communication, implementation, evidence, and revision. They are weakest when used only as a required diagram.

Back to top ↑

The Limits of Logic Models and Theory of Change

Logic models and Theory of Change frameworks have limits. They can make complex change look more linear than it is. They can hide power dynamics, uncertainty, unintended consequences, competing incentives, feedback loops, and external shocks. They can also become compliance documents that satisfy funders or managers without guiding real learning.

A simple pathway can be helpful, but social, institutional, technological, educational, and policy systems rarely behave in simple chains. Many outcomes depend on feedback, adaptation, context, timing, trust, resources, and actors outside the initiative’s control.

The corrective move is not to abandon these frameworks. It is to govern them as living theories rather than static diagrams.

Back to top ↑

Relationship to OKRs, KPIs, SWOT, Policy Explanation, and Systems Thinking

Logic models and Theory of Change frameworks work best alongside other frameworks. OKRs define strategic priorities and measurable progress. KPIs monitor performance and system health. SWOT identifies internal and external conditions. Policy explanation frameworks show how rules, institutions, incentives, and governance mechanisms are expected to produce public outcomes. Systems thinking reveals feedback loops, delays, boundaries, and unintended consequences.

Logic models and Theory of Change frameworks explain how change is expected to happen. Other frameworks test strategy, context, measurement, systems behavior, and communication.

Back to top ↑

How Logic Models Support Content Frameworks

Logic models support content frameworks by connecting editorial work to intended outcomes. A content framework may include article maps, topic clusters, metadata systems, internal links, companion code, governance queues, and learning pathways. A logic model can show how those components are expected to improve navigation, comprehension, reuse, trust, and maintenance.

Theory of Change work adds the causal reasoning. It asks why structured article maps should help readers, why companion repositories should improve learning, why metadata should support discoverability, and why governance queues should improve quality. These assumptions can then be tested through measurement frameworks.

In a Catalyst Canvas-ready system, logic-model records can become structured assets: input, activity, output, outcome, assumption, evidence strength, indicator, owner, review date, risk flag, and recommended governance action.

Back to top ↑

Ethics, Power, and Causal Claims

Logic models and Theory of Change frameworks are not neutral. They define what counts as a problem, what counts as success, whose outcomes matter, and which causal explanations are considered credible. Because of that, they can either reveal or hide power.

Ethical use requires stakeholder attention. A model should ask who designed the pathway, who benefits, who bears risk, whose evidence counts, whose experience is missing, and what unintended consequences may occur. This matters in public policy, education, nonprofit programs, sustainability work, health communication, institutional governance, and content systems.

• Stakeholder inclusion: Include the people affected by the pathway, not only the people funding or managing it.
• Assumption transparency: State what must be true for the model to work.
• Evidence humility: Distinguish proven links from hypotheses.
• Power analysis: Identify who defines outcomes and who has authority to act.
• Unintended consequences: Review possible harms, burdens, exclusions, or distortions.
• Revision discipline: Update the model when evidence or context changes.

Responsible causal frameworks do not just say “this leads to that.” They explain why, for whom, under what conditions, with what evidence, and with what accountability.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

Logic models and Theory of Change frameworks can be supported by computational audits that score pathway completeness, evidence strength, assumption risk, outcome clarity, measurement coverage, and governance priority. These scores do not prove causality. They help teams identify weak parts of a model before the model is used for strategy, funding, communication, or evaluation.

A simple pathway completeness score can measure whether each major layer is present:

An evidence-weighted causal confidence score can combine evidence strength across causal links:

An assumption-risk score can increase when assumptions are important but weakly supported:

A governance priority score can combine evidence gaps, assumption risk, and weak measurement coverage:

Computational audits help keep causal frameworks honest. They do not replace evaluation, stakeholder review, or judgment.

Back to top ↑

Python Workflow: Logic Model and Theory of Change Audit

The Python workflow below evaluates logic-model and Theory of Change records by model layer, causal link, evidence strength, assumption importance, assumption evidence, measurement coverage, outcome clarity, claim strength, owner, and governance status. The companion repository version extends this into a Catalyst Canvas-ready module with schemas, package-style Python, tests, JSON exports, Canvas cards, shared contracts, and governance queues.

# logic_model_audit.py
# Dependency-light workflow for logic model and Theory of Change governance.

from __future__ import annotations

from dataclasses import dataclass
from pathlib import Path
import csv
from statistics import mean

ARTICLE_ROOT = Path(__file__).resolve().parents[1]
TABLES = ARTICLE_ROOT / "outputs" / "tables"


@dataclass
class LogicModelElement:
    element: str
    model_layer: str
    description: str
    evidence_strength: float
    assumption_importance: float
    assumption_evidence: float
    measurement_coverage: float
    outcome_clarity: float
    claim_strength: float
    owner: str
    status: str

    def assumption_risk(self) -> float:
        return self.assumption_importance * (1 - self.assumption_evidence)

    def evidence_gap(self) -> float:
        return max(0.0, self.claim_strength - self.evidence_strength)

    def pathway_quality(self) -> float:
        return mean([
            self.evidence_strength,
            self.assumption_evidence,
            self.measurement_coverage,
            self.outcome_clarity,
        ])

    def governance_priority(self) -> float:
        return min(
            1.0,
            self.evidence_gap() * 0.35
            + self.assumption_risk() * 0.35
            + (1 - self.measurement_coverage) * 0.20
            + (1 - self.outcome_clarity) * 0.10,
        )

    def review_priority(self) -> str:
        if self.status == "revise" or self.evidence_gap() >= 0.30:
            return "high"
        if self.governance_priority() >= 0.45 or self.assumption_risk() >= 0.40:
            return "medium"
        if self.status == "review":
            return "medium"
        return "standard"


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        raise ValueError(f"No rows to write: {path}")
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0].keys()))
        writer.writeheader()
        writer.writerows(rows)


def main() -> None:
    elements = [
        LogicModelElement("Article maps", "output", "Structured article maps organize topic pathways and series navigation.", 0.78, 0.72, 0.66, 0.80, 0.82, 0.82, "editorial", "active"),
        LogicModelElement("Improved reader navigation", "outcome", "Readers move through related framework articles with fewer dead ends.", 0.66, 0.82, 0.54, 0.62, 0.76, 0.84, "editorial", "review"),
        LogicModelElement("Companion repositories", "output", "Canvas-ready repositories provide reusable workflows and generated outputs.", 0.74, 0.70, 0.58, 0.78, 0.72, 0.82, "platform", "review"),
        LogicModelElement("Public reasoning impact", "impact", "Structured frameworks may support more careful public reasoning over time.", 0.42, 0.90, 0.36, 0.34, 0.52, 0.78, "strategy", "revise"),
        LogicModelElement("Governance queue resolution", "activity", "Review and resolve high-priority evidence and maintenance issues.", 0.76, 0.68, 0.70, 0.86, 0.80, 0.80, "governance", "active"),
    ]

    rows = []

    for element in elements:
        rows.append({
            "element": element.element,
            "model_layer": element.model_layer,
            "description": element.description,
            "evidence_strength": element.evidence_strength,
            "assumption_importance": element.assumption_importance,
            "assumption_evidence": element.assumption_evidence,
            "measurement_coverage": element.measurement_coverage,
            "outcome_clarity": element.outcome_clarity,
            "claim_strength": element.claim_strength,
            "assumption_risk": round(element.assumption_risk(), 3),
            "evidence_gap": round(element.evidence_gap(), 3),
            "pathway_quality": round(element.pathway_quality(), 3),
            "governance_priority": round(element.governance_priority(), 3),
            "owner": element.owner,
            "status": element.status,
            "review_priority": element.review_priority(),
        })

    rows = sorted(rows, key=lambda row: row["governance_priority"], reverse=True)
    write_csv(TABLES / "logic_model_audit.csv", rows)

    governance_queue = [
        row for row in rows
        if row["review_priority"] != "standard"
    ]

    write_csv(TABLES / "logic_model_governance_queue.csv", governance_queue)

    print("Logic model and Theory of Change audit complete.")


if __name__ == "__main__":
    main()

This workflow helps teams identify weak causal links, unsupported assumptions, poorly measured outcomes, and impact claims that need review before they are used in strategy or communication.

Back to top ↑

R Workflow: Causal Pathway and Evidence Diagnostics

The R workflow below creates a logic-model dataset, calculates assumption risk, evidence gaps, pathway quality, governance priority, and review status, then exports summary tables and base R plots. It is intentionally portable and uses only base R.

# logic_model_report.R
# Base R workflow for logic model and Theory of Change diagnostics.

args <- commandArgs(trailingOnly = FALSE)
file_arg <- grep("^--file=", args, value = TRUE)

if (length(file_arg) > 0) {
  script_path <- normalizePath(sub("^--file=", "", file_arg[1]), mustWork = TRUE)
  article_root <- normalizePath(file.path(dirname(script_path), ".."), mustWork = TRUE)
} else {
  article_root <- getwd()
}

setwd(article_root)

tables_dir <- file.path(article_root, "outputs", "tables")
figures_dir <- file.path(article_root, "outputs", "figures")

if (!dir.exists(tables_dir)) {
  dir.create(tables_dir, recursive = TRUE)
}

if (!dir.exists(figures_dir)) {
  dir.create(figures_dir, recursive = TRUE)
}

elements <- data.frame(
  element = c(
    "Article maps",
    "Improved reader navigation",
    "Companion repositories",
    "Public reasoning impact",
    "Governance queue resolution"
  ),
  model_layer = c("output", "outcome", "output", "impact", "activity"),
  evidence_strength = c(0.78, 0.66, 0.74, 0.42, 0.76),
  assumption_importance = c(0.72, 0.82, 0.70, 0.90, 0.68),
  assumption_evidence = c(0.66, 0.54, 0.58, 0.36, 0.70),
  measurement_coverage = c(0.80, 0.62, 0.78, 0.34, 0.86),
  outcome_clarity = c(0.82, 0.76, 0.72, 0.52, 0.80),
  claim_strength = c(0.82, 0.84, 0.82, 0.78, 0.80),
  owner = c("editorial", "editorial", "platform", "strategy", "governance"),
  status = c("active", "review", "review", "revise", "active"),
  stringsAsFactors = FALSE
)

elements$assumption_risk <- elements$assumption_importance * (1 - elements$assumption_evidence)

elements$evidence_gap <- pmax(0, elements$claim_strength - elements$evidence_strength)

elements$pathway_quality <- rowMeans(elements[, c(
  "evidence_strength",
  "assumption_evidence",
  "measurement_coverage",
  "outcome_clarity"
)])

elements$governance_priority <- pmin(
  1,
  elements$evidence_gap * 0.35 +
    elements$assumption_risk * 0.35 +
    (1 - elements$measurement_coverage) * 0.20 +
    (1 - elements$outcome_clarity) * 0.10
)

elements$review_priority <- ifelse(
  elements$status == "revise" | elements$evidence_gap >= 0.30,
  "high",
  ifelse(
    elements$governance_priority >= 0.45 |
      elements$assumption_risk >= 0.40 |
      elements$status == "review",
    "medium",
    "standard"
  )
)

elements <- elements[order(elements$governance_priority, decreasing = TRUE), ]

write.csv(
  elements,
  file.path(tables_dir, "logic_model_summary.csv"),
  row.names = FALSE
)

governance_queue <- elements[elements$review_priority != "standard", ]

write.csv(
  governance_queue,
  file.path(tables_dir, "logic_model_governance_queue.csv"),
  row.names = FALSE
)

png(file.path(figures_dir, "logic_model_governance_priority.png"), width = 1200, height = 700)
barplot(
  elements$governance_priority,
  names.arg = elements$element,
  las = 2,
  ylab = "Governance priority",
  main = "Logic Model Governance Priority"
)
grid()
dev.off()

png(file.path(figures_dir, "logic_model_pathway_quality.png"), width = 1000, height = 700)
barplot(
  elements$pathway_quality,
  names.arg = elements$element,
  las = 2,
  ylab = "Pathway quality",
  main = "Logic Model Pathway Quality"
)
grid()
dev.off()

print(elements[, c("element", "model_layer", "pathway_quality", "assumption_risk", "evidence_gap", "governance_priority", "review_priority")])

This workflow turns causal pathway review into an auditable artifact. It helps identify weak evidence, high-risk assumptions, poor measurement coverage, vague outcomes, and impact claims that require review.

Back to top ↑

GitHub Repository

The companion repository for this article supports logic models and Theory of Change frameworks as a Catalyst Canvas-ready content-framework module. It includes causal-pathway classification, model-layer diagnostics, assumption-risk scoring, evidence-gap analysis, measurement coverage, governance status, JSON schemas, package-style Python, tests, Canvas card outputs, markdown governance queues, synthetic datasets, SQL views, documentation, and multi-language scaffolds for causal framework governance.

articles/logic-models-and-theory-of-change-frameworks/
├── canvas/
│   ├── canvas_manifest.json
│   ├── input_schema.json
│   ├── output_schema.json
│   ├── canvas_cards.json
│   └── governance_queue.json
├── html/
├── css/
├── php/
├── java/
├── python/
│   ├── logic_model_canvas/
│   │   ├── __init__.py
│   │   ├── __main__.py
│   │   ├── cli.py
│   │   ├── models.py
│   │   ├── scoring.py
│   │   ├── validation.py
│   │   ├── governance.py
│   │   └── exporters.py
│   ├── tests/
│   │   └── test_logic_model_canvas.py
│   └── run_logic_model_canvas_audit.py
├── r/
│   ├── logic_model_report.R
│   └── run_all_logic_model_workflows.R
├── sql/
│   ├── canvas_schema.sql
│   └── canvas_queries.sql
├── docs/
├── data/
├── outputs/
│   ├── figures/
│   ├── json/
│   ├── markdown/
│   └── tables/
├── notebooks/
├── shared/
└── README.md

Back to top ↑

Back to top ↑

Back to top ↑

Why Causal Frameworks Need Governance

Logic models and Theory of Change frameworks help teams explain how action is expected to produce change. They connect resources, activities, outputs, outcomes, assumptions, evidence, and impact. They are useful because they make causal reasoning visible. They are risky because visible pathways can look more certain than they are.

Good causal frameworks are not static. They should be revised as evidence changes, assumptions fail, stakeholders respond, contexts shift, and unintended consequences appear. The framework should help teams learn, not merely justify what they already planned to do.

Used responsibly, logic models and Theory of Change frameworks help writers, strategists, editors, researchers, educators, policymakers, and organizations communicate change with greater clarity and humility. They should be paired with OKRs, KPIs, evaluation plans, content audits, systems thinking, stakeholder review, and governance workflows. In a content-framework system, they help ensure that knowledge architecture is not only well organized, but also tied to evidence, learning, accountability, and responsible claims about impact.

Back to top ↑

Related Articles

• OKRs, KPIs, and Measurement Frameworks
• Frameworks for Policy Explanation and Governance Communication
• Content Audits and Framework Governance
• SWOT Analysis: Strengths, Uses, and Limits
• Systems Explanation Frameworks
• Framework Governance and Editorial Maintenance

Further Reading

• W. K. Kellogg Foundation (2004) Logic Model Development Guide. Battle Creek, MI: W. K. Kellogg Foundation. Available at: https://www.wkkf.org/resources/
• Centers for Disease Control and Prevention (n.d.) Logic Models. CDC Library Research Guides. Available at: https://www.cdc.gov/library/research-guides/logic-models.html
• Centers for Disease Control and Prevention (n.d.) Developing and Using a Logic Model. CDC. Available at: https://www.cdc.gov/cardiovascular-resources/php/toolkit/developing-and-using-a-logic-model.html
• Centers for Disease Control and Prevention (n.d.) Step 2: Describe the Program. Program Evaluation Framework Action Guide. Available at: https://www.cdc.gov/evaluation/php/evaluation-framework-action-guide/step-2-describe-the-program.html
• BetterEvaluation (n.d.) Describe the Theory of Change. BetterEvaluation. Available at: https://www.betterevaluation.org/frameworks-guides/managers-guide-evaluation/scope-evaluation/describe-theory-change
• BetterEvaluation (n.d.) Develop Programme Theory / Theory of Change. BetterEvaluation Rainbow Framework. Available at: https://www.betterevaluation.org/frameworks-guides/rainbow-framework/define/develop-programme-theory-theory-change
• Rogers, P. (2014) Theory of Change. UNICEF Office of Research – Innocenti and BetterEvaluation. Available at: https://www.betterevaluation.org/tools-resources/theory-change-0
• OECD DAC Network on Development Evaluation (n.d.) Evaluation Criteria. OECD. Available at: https://www.oecd.org/en/topics/sub-issues/development-co-operation-evaluation-and-effectiveness/evaluation-criteria.html
• OECD DAC Network on Development Evaluation (2019) Better Criteria for Better Evaluation: Revised Evaluation Criteria Definitions and Principles for Use. Paris: OECD. Available at: https://www.oecd.org/en/publications/better-criteria-for-better-evaluation_15a9c26b-en.html
• World Bank (n.d.) Designing a Results Framework for Achieving Results: A How-to Guide. World Bank Open Knowledge Repository. Available at: https://openknowledge.worldbank.org/entities/publication/337883df-2733-5f10-b8f5-a930026703e6
• World Bank Development Impact Evaluation (n.d.) Theory of Change. DIME Wiki. Available at: https://dimewiki.worldbank.org/Theory_of_Change
• University of Kansas Center for Community Health and Development (n.d.) Developing a Logic Model or Theory of Change. Community Tool Box. Available at: https://ctb.ku.edu/en/table-of-contents/overview/models-for-community-health-and-development/logic-model-development/main
• Google Search Central (n.d.) Creating Helpful, Reliable, People-First Content. Google for Developers. Available at: https://developers.google.com/search/docs/fundamentals/creating-helpful-content
• Google Search Central (n.d.) Google Search Essentials. Google for Developers. Available at: https://developers.google.com/search/docs/essentials
• Google Search Central (2023) Google Search’s Guidance About AI-Generated Content. Google Search Central Blog. Available at: https://developers.google.com/search/blog/2023/02/google-search-and-ai-content
• Funnell, S.C. and Rogers, P.J. (2011) Purposeful Program Theory: Effective Use of Theories of Change and Logic Models. San Francisco, CA: Jossey-Bass.
• Chen, H.T. (1990) Theory-Driven Evaluations. Newbury Park, CA: Sage.
• Pawson, R. and Tilley, N. (1997) Realistic Evaluation. London: Sage.
• Mayne, J. (2012) ‘Contribution analysis: Coming of age?’, Evaluation, 18(3), pp. 270–280.
• Rogers, P.J. (2008) ‘Using programme theory to evaluate complicated and complex aspects of interventions’, Evaluation, 14(1), pp. 29–48.

References

• W. K. Kellogg Foundation (2004) Logic Model Development Guide. Battle Creek, MI: W. K. Kellogg Foundation. Available at: https://www.wkkf.org/resources/
• Centers for Disease Control and Prevention (n.d.) Logic Models. CDC Library Research Guides. Available at: https://www.cdc.gov/library/research-guides/logic-models.html
• Centers for Disease Control and Prevention (n.d.) Developing and Using a Logic Model. CDC. Available at: https://www.cdc.gov/cardiovascular-resources/php/toolkit/developing-and-using-a-logic-model.html
• Centers for Disease Control and Prevention (n.d.) Step 2: Describe the Program. Program Evaluation Framework Action Guide. Available at: https://www.cdc.gov/evaluation/php/evaluation-framework-action-guide/step-2-describe-the-program.html
• BetterEvaluation (n.d.) Describe the Theory of Change. BetterEvaluation. Available at: https://www.betterevaluation.org/frameworks-guides/managers-guide-evaluation/scope-evaluation/describe-theory-change
• BetterEvaluation (n.d.) Develop Programme Theory / Theory of Change. BetterEvaluation Rainbow Framework. Available at: https://www.betterevaluation.org/frameworks-guides/rainbow-framework/define/develop-programme-theory-theory-change
• Rogers, P. (2014) Theory of Change. UNICEF Office of Research – Innocenti and BetterEvaluation. Available at: https://www.betterevaluation.org/tools-resources/theory-change-0
• OECD DAC Network on Development Evaluation (2019) Better Criteria for Better Evaluation: Revised Evaluation Criteria Definitions and Principles for Use. Paris: OECD. Available at: https://www.oecd.org/en/publications/better-criteria-for-better-evaluation_15a9c26b-en.html
• World Bank (n.d.) Designing a Results Framework for Achieving Results: A How-to Guide. World Bank Open Knowledge Repository. Available at: https://openknowledge.worldbank.org/entities/publication/337883df-2733-5f10-b8f5-a930026703e6
• World Bank Development Impact Evaluation (n.d.) Theory of Change. DIME Wiki. Available at: https://dimewiki.worldbank.org/Theory_of_Change
• University of Kansas Center for Community Health and Development (n.d.) Developing a Logic Model or Theory of Change. Community Tool Box. Available at: https://ctb.ku.edu/en/table-of-contents/overview/models-for-community-health-and-development/logic-model-development/main
• Google Search Central (n.d.) Creating Helpful, Reliable, People-First Content. Google for Developers. Available at: https://developers.google.com/search/docs/fundamentals/creating-helpful-content
• Google Search Central (n.d.) Google Search Essentials. Google for Developers. Available at: https://developers.google.com/search/docs/essentials
• Google Search Central (2023) Google Search’s Guidance About AI-Generated Content. Google Search Central Blog. Available at: https://developers.google.com/search/blog/2023/02/google-search-and-ai-content
• Weiss, C.H. (1995) ‘Nothing as practical as good theory: Exploring theory-based evaluation for comprehensive community initiatives for children and families’, in Connell, J.P., Kubisch, A.C., Schorr, L.B. and Weiss, C.H. (eds.) New Approaches to Evaluating Community Initiatives: Concepts, Methods, and Contexts. Washington, DC: Aspen Institute.
• Chen, H.T. (1990) Theory-Driven Evaluations. Newbury Park, CA: Sage.
• Funnell, S.C. and Rogers, P.J. (2011) Purposeful Program Theory: Effective Use of Theories of Change and Logic Models. San Francisco, CA: Jossey-Bass.
• Rogers, P.J. (2008) ‘Using programme theory to evaluate complicated and complex aspects of interventions’, Evaluation, 14(1), pp. 29–48.
• Mayne, J. (2012) ‘Contribution analysis: Coming of age?’, Evaluation, 18(3), pp. 270–280.
• Pawson, R. and Tilley, N. (1997) Realistic Evaluation. London: Sage.

Back to top ↑