Systems Thinking in Organizations and Learning

Last Updated June 1, 2026

Organizations are systems of people, routines, incentives, decisions, information flows, tools, authority, memory, culture, and feedback. They do not simply execute strategy. They interpret signals, protect habits, respond to pressure, reproduce assumptions, and learn unevenly over time. When organizations succeed, it is rarely because individual talent alone is enough. When they fail repeatedly, it is rarely because individuals are simply careless, resistant, or unmotivated. Organizational behavior emerges from structure.

Systems thinking in organizations asks why the same problems keep returning: recurring burnout, failed change initiatives, poor handoffs, weak communication, siloed decision-making, repeated mistakes, defensive routines, misaligned incentives, lost institutional memory, quality problems, and reforms that fade after initial enthusiasm. These patterns are often produced by feedback loops, delays, mental models, authority structures, workload design, local optimization, measurement systems, and organizational learning failures. To improve an organization, leaders must understand not only what people do, but what the system makes reasonable, rewarded, risky, invisible, or impossible.

This article examines systems thinking in organizations and learning. It explains how organizations behave as complex adaptive systems, how routines and incentives shape action, why feedback is often delayed or distorted, and why repeated failure usually reflects structure rather than isolated individual error. It explores organizational learning, mental models, silos, local optimization, defensive routines, institutional memory, double-loop learning, power, culture, and redesign. It also asks how organizations can become more capable of learning without blame, denial, burnout, or superficial reform.

Why Organizational Systems Thinking Matters

Organizational systems thinking matters because many organizations misdiagnose recurring problems. A deadline is missed, so leaders ask people to work harder. A customer complaint appears, so a team is retrained. A project fails, so a new tool is purchased. A mistake occurs, so a new approval step is added. A department underperforms, so targets are increased. Each response may appear reasonable in isolation, but repeated problems often point to deeper structure: unclear authority, poor information flows, unrealistic workload, misaligned incentives, weak institutional memory, delayed feedback, defensive routines, or conflicting goals.

Organizations are especially vulnerable to surface explanations because individual behavior is visible while structure is often hidden. A person misses a handoff. A team fails to communicate. A manager delays a decision. A frontline worker creates a workaround. These events are easy to see. Less visible are the feedback loops that produced them: overloaded calendars, fragmented tools, unclear ownership, competing metrics, fear of blame, informal power, staffing shortages, missing documentation, and incentives that reward local success over whole-system performance.

Systems thinking changes the diagnostic question. Instead of asking only “Who failed?” it asks “What system made this failure likely?” Instead of asking only “How do we correct this person?” it asks “What feedback, routine, rule, incentive, delay, or boundary is reproducing the pattern?” Instead of asking only “How do we make people comply?” it asks “What structure would make the desired behavior easier, safer, better rewarded, and more meaningful?”

Organizational systems thinking is not an excuse for poor behavior. It is a more serious form of accountability. If the same problem keeps returning, the organization must examine the structure that makes the behavior likely. Accountability should reach the system, not stop at the nearest person.

Back to top ↑

Organizations as Systems

An organization is a system because its behavior emerges from relationships among parts. Teams, roles, policies, tools, budgets, incentives, leaders, norms, customers, regulators, suppliers, technologies, and informal networks interact. The organization’s performance cannot be understood by examining each part in isolation. The relationships among parts often matter more than the parts themselves.

For example, a team may be skilled, but if it receives unclear requirements, delayed decisions, conflicting priorities, and unstable tools, its performance will suffer. A manager may be competent, but if the organization rewards short-term output while ignoring long-term capacity, the manager may make decisions that deplete the team. A process may look efficient inside one department while creating rework for another. A metric may improve locally while damaging the whole system.

Organizations also contain stocks and flows. Stocks include trust, skill, institutional memory, backlog, morale, credibility, technical debt, social capital, knowledge, capacity, and fatigue. Flows include hiring, turnover, learning, forgetting, information, decisions, work requests, errors, rework, support, and recovery. Many organizational problems are stock-flow problems disguised as personnel problems.

Organizations are also adaptive. People learn how the system actually works. They discover what is rewarded, what is ignored, what is risky, what can be said, what must be hidden, which metrics matter, which rules are flexible, which leaders listen, which problems are safe to raise, and which workarounds are necessary. Formal structure matters, but informal adaptation often determines real behavior.

A systems view asks:

• What behavior does the organization repeatedly produce?
• What feedback loops reinforce that behavior?
• What stocks are being built or depleted?
• What incentives shape local decisions?
• Where is information delayed, distorted, or blocked?
• What mental models define success, risk, quality, and responsibility?
• Who has authority to change the structure?
• Who carries the burden when the structure fails?

Organizations are not machines, even when leaders describe them that way. They are living social systems with memory, fear, trust, aspiration, power, learning, habit, and adaptation. Systems thinking helps organizations see themselves more honestly.

Back to top ↑

Routines, Habits, and Structural Repetition

Routines are the repeated patterns through which organizations operate. They include meetings, approval processes, reporting cycles, handoffs, escalations, reviews, budgeting rhythms, hiring practices, onboarding, documentation habits, customer responses, and informal workarounds. Routines make coordination possible, but they also preserve old assumptions. An organization’s routines often reveal its real operating logic more clearly than its stated values.

Routines can become structural repetition. A team always rushes at the end of a project. A department always receives incomplete information. A leader always intervenes too late. A budget cycle always cuts preventive work. A performance review always rewards visible output over long-term learning. These patterns are not random. They are routines interacting with incentives, delays, and authority.

Organizational learning begins when routines become visible. People often experience routines as “just how things work.” Systems thinking turns that familiarity into evidence. If a workaround is repeated, it is a signal. If the same escalation happens every quarter, it is a signal. If people always avoid one meeting, delay one approval, or rewrite one document, those behaviors reveal system design.

Routines are not always bad. They can preserve excellence, safety, reliability, and shared learning. The question is whether a routine helps the organization learn or helps it avoid learning. A routine that preserves feedback, clarifies responsibility, and reduces burden is valuable. A routine that hides conflict, delays decisions, shifts blame, or normalizes overload becomes a structural trap.

To change an organization, leaders must often change routines. Strategy does not become real until it changes what people repeatedly do.

Back to top ↑

Feedback in Organizations

Feedback is how organizations learn. A decision produces an outcome. The outcome generates information. The organization interprets that information and adjusts. In a healthy learning system, feedback is timely, trustworthy, specific, and connected to authority. In a weak learning system, feedback is delayed, filtered, punished, ignored, distorted, or separated from the people who can act on it.

Organizational feedback is often weaker than leaders believe. Dashboards may show activity but not meaning. Surveys may collect sentiment but not change decisions. Reports may document problems but not reach authority. Frontline knowledge may be dismissed because it conflicts with official metrics. Customers may complain after harm has already occurred. Employees may stop giving feedback because nothing changes.

Feedback can fail in several ways:

• Delay: information arrives after decisions have already locked in consequences.
• Distortion: bad news is softened as it moves upward.
• Fear: people hide problems because reporting risk is high.
• Overload: too much data makes signals hard to interpret.
• Metric narrowness: the organization measures proxies instead of outcomes.
• Siloing: feedback stays in one department and never reaches the whole system.
• No authority: people who see the problem cannot change the structure.
• No memory: lessons are not preserved, so the organization relearns the same thing repeatedly.

Feedback quality is an organizational justice issue. Frontline workers, customers, communities, and lower-status employees often see system failure first. If their feedback is dismissed, the organization loses its best early warning system. A hierarchy that cannot hear downward, outward, or marginal feedback will learn late, poorly, or not at all.

Organizations that learn well design feedback intentionally. They ask who sees the problem first, how the signal travels, what incentives shape reporting, how feedback is interpreted, who has authority to act, and whether the organization remembers the lesson. Feedback is not simply data. It is a relationship between experience and change.

Back to top ↑

Incentives and Local Optimization

Organizations often fail because local optimization damages whole-system performance. A department improves its metric while creating rework elsewhere. A sales team promises delivery timelines that operations cannot meet. A support team reduces call time but increases repeat contacts. A manager protects a budget by deferring maintenance, training, documentation, or staffing. A team meets output targets while depleting trust, quality, or human capacity.

Local optimization occurs when parts of the system are rewarded for their own success rather than the health of the whole. This is especially common when budgets, metrics, authority, and accountability are organized by function. Each unit tries to succeed within its own boundary. The organization then suffers from boundary blindness.

Examples include:

• sales growth that creates delivery failure;
• cost cutting that increases turnover and rework;
• speed targets that reduce quality;
• risk controls that create administrative burden;
• product launches that increase support load;
• budget savings that create future maintenance costs;
• technology adoption that shifts work to users or frontline staff;
• team-level productivity that depletes shared organizational capacity.

Local optimization is not usually caused by bad people. It is caused by narrow accountability. If a team is measured and rewarded locally, it will often optimize locally. Systems thinking asks whether the organization’s measurement and incentive systems encourage people to improve the whole or protect the part.

Whole-system learning requires shared metrics, cross-functional feedback, visible handoff costs, and authority to redesign boundaries. Otherwise, the organization keeps rewarding local success while experiencing collective failure.

Back to top ↑

Mental Models and Organizational Assumptions

Mental models are the assumptions people use to interpret reality. In organizations, mental models define what leaders think the problem is, what counts as evidence, what kind of behavior is expected from employees, what risk means, what customers value, what quality looks like, what counts as productivity, and what change is considered realistic. Mental models are powerful because they shape what the organization can see.

An organization operating from a control mental model may interpret mistakes as failures of compliance. Its response will be more rules, more approvals, more surveillance, and more punishment. An organization operating from a learning mental model may interpret mistakes as signals about process, training, design, workload, or feedback. Its response will be investigation, redesign, and knowledge-sharing. The same event produces different action because the mental model differs.

Organizational mental models often hide inside common phrases:

• “People just need to take ownership.”
• “We need more urgency.”
• “The process is fine; people are not following it.”
• “If it mattered, someone would have escalated it.”
• “We cannot slow down.”
• “That is not our department.”
• “The dashboard says we are on track.”
• “We tried that before.”

These phrases may contain truth, but they can also protect assumptions. Systems thinking asks what each phrase makes visible and what it hides. “People need to take ownership” may hide unclear authority. “We need more urgency” may hide chronic overload. “That is not our department” may hide boundary failure. “The dashboard says we are on track” may hide unmeasured burden.

Changing mental models requires more than presenting facts. Organizational assumptions are tied to identity, authority, expertise, fear, status, and past success. People may defend a mental model because it once worked, because it protects power, or because alternatives feel risky. A learning organization creates spaces where assumptions can be examined without immediate blame or defensiveness.

Systems thinking helps organizations ask: what do we believe about this system, how do those beliefs shape our actions, and what evidence would cause us to revise them?

Back to top ↑

Single-Loop and Double-Loop Learning

Organizational learning can be shallow or deep. Single-loop learning corrects errors within existing goals, rules, and assumptions. Double-loop learning questions the goals, rules, and assumptions themselves. Both are necessary, but they serve different purposes.

Single-loop learning asks, “Are we doing the thing right?” It adjusts tactics. A process is too slow, so the organization removes a step. A dashboard is unclear, so the organization improves reporting. A training gap appears, so the organization updates onboarding. Single-loop learning is useful for improving performance within a stable frame.

Double-loop learning asks, “Are we doing the right thing, and are our assumptions valid?” It examines the governing structure. A process is too slow because the rules are needlessly complex. A dashboard is unclear because the organization measures activity instead of value. Training gaps recur because the organization relies on informal knowledge rather than institutional memory. Double-loop learning changes the frame.

Organizations often prefer single-loop learning because it is less threatening. It improves the system without questioning the system. Double-loop learning is harder because it may challenge leadership assumptions, power, incentives, culture, strategy, or identity. But without double-loop learning, organizations can become very efficient at preserving the wrong structure.

A learning organization needs both. Single-loop learning improves reliability. Double-loop learning prevents the organization from optimizing around false assumptions.

Back to top ↑

Defensive Routines and Learning Avoidance

Defensive routines are patterns that protect people or organizations from embarrassment, threat, blame, or loss of control, but also prevent learning. They can appear as silence, blame-shifting, vague language, premature certainty, over-polished reporting, avoidance of conflict, hidden disagreement, ritualized meetings, or explanations that protect existing authority. Defensive routines help the organization feel safe from discomfort while making it less safe from failure.

Defensive routines are especially common when bad news is punished. If people are blamed for reporting problems, they will learn to hide problems. If leaders react defensively to criticism, teams will soften feedback. If metrics punish deviation, people will manage appearances. If disagreement threatens careers, dissent will move underground. The organization may appear aligned while losing access to reality.

Defensive routines often take subtle forms:

• meetings where everyone agrees publicly but disagrees privately;
• status reports that hide uncertainty;
• postmortems that identify “communication” as the cause without examining structure;
• leaders asking for honesty but rewarding optimism;
• teams avoiding known risks because escalation is costly;
• processes that require sign-off but not real understanding;
• lessons learned documents that are created but never used;
• language that makes responsibility diffuse without changing authority.

Defensive routines are not only psychological. They are structural. People become defensive when the system makes honesty costly. Therefore, telling people to be more transparent is not enough. The organization must redesign the conditions under which feedback is given and used.

Learning without defensiveness requires psychological safety, but psychological safety is not politeness. It is the practical ability to raise real problems without being punished, ignored, or isolated. It must be supported by leadership behavior, authority structures, fair investigation, and visible change after feedback is given.

A defensive organization protects itself from discomfort. A learning organization protects itself from repeated failure.

Back to top ↑

Silos and Information Flows

Silos are not only social barriers. They are structural boundaries in information, incentives, budgets, tools, authority, and identity. A silo forms when one part of the organization optimizes around its own goals while lacking visibility into how its actions affect the rest of the system. Silos can preserve expertise, but they can also block learning.

Information flows determine what the organization can know. If information moves slowly, decisions lag. If information is filtered, leaders see a softened version of reality. If information is trapped inside departments, cross-boundary problems persist. If frontline knowledge does not reach strategy, plans become detached from implementation. If customer experience does not reach product design, problems repeat. If data is centralized without context, interpretation becomes weak.

Many organizational problems are handoff problems. Work crosses boundaries, but accountability does not. One team completes its task and passes hidden complexity to another. Another team absorbs rework. A customer or employee experiences the gap. The organization sees departmental performance but misses system performance.

Silo problems often include:

• different departments using different definitions of success;
• handoffs without shared ownership;
• tools that do not preserve context across teams;
• budgets that reward cost shifting;
• leaders who see summaries but not lived process;
• frontline workarounds invisible to planners;
• repeated escalation because no one owns the boundary;
• local metrics that hide whole-system burden.

Fixing silos requires more than telling people to collaborate. Collaboration is difficult when the structure rewards separation. The organization may need shared goals, cross-functional accountability, integrated information systems, boundary-spanning roles, common definitions, visible handoff costs, and authority to redesign work across departments.

Silos persist when information, authority, and accountability do not cross the same boundaries as the work.

Back to top ↑

Institutional Memory and Learning Decay

Institutional memory is the organization’s ability to preserve and use what it has learned. It includes documentation, stories, data, routines, relationships, technical knowledge, decision history, design rationale, customer knowledge, community trust, and lessons from past failure. Without institutional memory, organizations repeat mistakes because learning remains trapped in individuals, meetings, or forgotten files.

Learning decay occurs when knowledge leaves faster than it is preserved. Turnover, restructuring, tool changes, poor documentation, weak onboarding, project rush, and lack of reflection all contribute. An organization may believe it has learned a lesson, but if the lesson is not embedded in process, training, tools, governance, and memory, it may disappear when people move on.

Institutional memory is not the same as having many documents. Memory must be usable. A buried archive, outdated wiki, unread postmortem, or inaccessible folder does not create learning. The organization must preserve knowledge in ways that support future decisions.

Useful institutional memory includes:

• why decisions were made, not only what decisions were made;
• what alternatives were considered and rejected;
• what assumptions proved wrong;
• what risks appeared late;
• what customers, users, or communities experienced;
• what workarounds emerged;
• what metrics were misleading;
• what should be done differently next time;
• who knows what and where that knowledge lives.

Institutional memory has ethical importance. When organizations forget, the cost often falls on people with less power: new employees, frontline workers, customers, patients, applicants, communities, or future teams. Forgetting becomes a way of shifting burden. People must rediscover what the organization should already know.

A learning organization treats memory as infrastructure. It designs knowledge systems, documentation, onboarding, postmortems, decision records, and feedback loops so that lessons survive beyond individual tenure. Without memory, learning becomes temporary performance.

Back to top ↑

Culture, Power, and Voice

Organizational culture is not just shared values. It is the pattern of what is safe, rewarded, punished, ignored, admired, hidden, repeated, and defended. Culture is produced by structure and power. Leaders shape it through decisions, incentives, reactions, promotions, stories, budget priorities, and what they tolerate. Employees learn culture by observing consequences.

Voice is central to organizational learning. An organization cannot learn what people are afraid to say. But voice is not distributed equally. People with status, security, expertise, tenure, race, gender, class, credential, or network advantage may speak more safely than others. Frontline workers may see system failure first but have the least authority to change it. Marginalized employees may carry the burden of naming harms that the dominant culture does not see.

Power determines which feedback is treated as legitimate. A senior leader’s concern may become strategy. A frontline worker’s concern may be treated as complaint. A customer’s complaint may be treated as anecdote. A community’s warning may be treated as resistance. Systems thinking asks whose knowledge reaches the system’s decision-making center and whose knowledge is filtered out.

Learning organizations must treat voice as a system design issue. Suggestion boxes and surveys are not enough. Voice needs protection, response, authority, and visible consequence. If people speak and nothing changes, voice becomes extraction. If people speak and are punished, silence becomes rational.

A serious learning organization does not ask only whether people are allowed to speak. It asks whether the organization is willing to be changed by what they know.

Back to top ↑

Organizational Burnout as a System Pattern

Burnout is often treated as an individual problem, but it is frequently an organizational system pattern. Workload exceeds capacity. Recovery is insufficient. Staffing lags demand. Rework increases. Meetings multiply. Priorities compete. High performers absorb more work. People compensate through overtime, emotional labor, hidden work, and personal sacrifice. The system appears to function because people are depleting themselves to hold it together.

Burnout becomes systemic when the organization relies on human depletion as a hidden resource. It uses commitment, professionalism, care, ambition, fear, or identity to absorb structural mismatch. People keep the system running, but the stock of human capacity declines. Eventually fatigue, error, disengagement, illness, turnover, conflict, and loss of institutional memory appear. The organization may then respond with wellness messaging while leaving workload structure unchanged.

Systems signs of organizational burnout include:

• constant urgency becomes normal;
• recovery time disappears;
• high performers receive more work because they are reliable;
• mistakes and rework rise;
• meetings increase because coordination is strained;
• turnover removes knowledge, creating more burden for remaining staff;
• wellness programs exist alongside unchanged workload;
• leaders praise resilience while ignoring depletion.

Organizational burnout often reflects multiple archetypes: fixes that fail, shifting the burden, success to the successful, eroding goals, and limits to growth. Overtime is a fix that fails. Burden shifts from structure to individuals. Successful employees receive more responsibility until they are depleted. Standards quietly erode as fatigue rises. Growth hits the limit of human capacity.

Addressing burnout requires redesign, not only support. The organization must examine demand, staffing, recovery, work-in-progress, decision delay, rework, priorities, meeting load, emotional labor, incentives, and authority. A system cannot sustainably ask people to compensate for structural failure with personal endurance.

Burnout is feedback. A learning organization treats it as information about design.

Back to top ↑

Organizational Redesign for Learning

Organizational redesign for learning changes the structures that determine whether feedback becomes improvement. It does not rely on motivation alone. It builds routines, incentives, tools, authority, and culture that make learning easier, safer, and more consequential.

A learning-oriented organization designs for several capabilities. It makes problems visible early. It protects people who report risk. It connects frontline knowledge to decision authority. It preserves institutional memory. It aligns incentives across boundaries. It measures capacity, quality, burden, and long-term outcomes. It creates time for reflection. It treats mistakes as information while maintaining accountability. It changes structure when repeated patterns reveal design failure.

Redesign can happen at many levels:

• Feedback redesign: improve signal quality, timing, and authority connection.
• Metric redesign: measure outcomes, burden, learning, and capacity, not only output.
• Routine redesign: replace ritual meetings with decision and learning routines.
• Boundary redesign: create shared accountability across handoffs.
• Workload redesign: match demand, staffing, recovery, and priorities.
• Knowledge redesign: preserve decision history, lessons, and reusable knowledge.
• Authority redesign: give problem-seeing actors power to improve the system.
• Culture redesign: reward truth-telling, learning, repair, and responsible dissent.

Learning redesign should be tested through behavior over time. Are problems detected earlier? Does rework decline? Does turnover slow? Does trust improve? Do lessons survive turnover? Do teams coordinate better across boundaries? Does workload become more sustainable? Does dissent become more useful? If the behavior pattern does not change, the redesign may still be superficial.

The goal is not to create a perfect organization. The goal is to create an organization that can notice, interpret, remember, and respond to its own feedback before failure becomes repeated pattern.

Back to top ↑

Ethics: Learning Without Blame or Extraction

Organizational learning has ethical stakes because learning often depends on the labor, honesty, and vulnerability of people inside and around the organization. Workers report problems. Customers experience harm. Communities give feedback. Frontline staff create workarounds. Marginalized employees name patterns that others do not see. If the organization collects this knowledge without changing structure, learning becomes extractive.

A responsible learning organization must distinguish accountability from blame. Blame isolates fault in a person and often protects the system from examination. Accountability asks who had responsibility, what decisions were made, what harm occurred, what repair is owed, and what structure must change. Blame can suppress learning. Accountability should deepen it.

Ethical organizational learning asks:

• Who is asked to report problems?
• Who is punished when problems become visible?
• Who benefits from the current structure?
• Who carries hidden work, emotional labor, or rework?
• Whose feedback is treated as credible?
• Does feedback change decisions, resources, or authority?
• Are people asked to be resilient instead of protected from preventable depletion?
• Does the organization repair harm or merely document it?
• Are learning systems accessible to lower-status and marginalized voices?
• Does the organization remember lessons after the people who taught them leave?

Ethical learning also requires attention to power. Leaders often ask for transparency while retaining the power to ignore what they hear. Employees may be told to speak up while promotion, security, and reputation remain at risk. Communities may be consulted without authority. A system that asks for voice without sharing power may produce participation without change.

Learning should reduce burden, not increase it. If every organizational lesson becomes another form, meeting, dashboard, or initiative added to already overloaded people, the learning system becomes part of the problem. Good learning redesign should simplify, clarify, repair, and build capacity.

An ethical learning organization does not treat people as sensors for management. It treats them as participants in shaping the system they help sustain.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

Organizational learning can be modeled through stock-flow diagrams, feedback loops, network analysis, queueing models, workload-capacity models, information-flow maps, agent-based simulations, and learning-decay equations. The goal is not to reduce organizational life to equations. The goal is to make hidden dynamics visible enough to test and redesign.

A simple organizational capacity model can be written as:

A workload-pressure model can be written as:

A burnout-risk model can include recovery:

Institutional memory can be represented as:

Feedback distortion can be represented conceptually as:

A learning-effectiveness measure can be represented as:

Computational modeling can reveal patterns that are difficult to see in day-to-day organizational life. It can show how small delays create large backlogs, how turnover destroys memory, how local optimization creates rework, how fear distorts feedback, and how overload becomes self-reinforcing. But models should be used as learning tools, not as substitutes for lived knowledge. Organizational systems include power, meaning, emotion, trust, and history. Good modeling makes those structures more discussable, not less human.

Back to top ↑

Python Workflow: Workload, Feedback, Memory, Burnout, and Learning-Redesign Diagnostics

The Python workflow below turns organizational learning analysis into a small reproducible systems model. It compares four scenarios: pressure without learning, dashboard and training reform, feedback and memory redesign, and learning organization redesign. It also includes one-at-a-time sensitivity analysis for the learning-organization scenario. The script uses only the Python standard library, writes CSV outputs relative to the article folder, and is designed as a clear starting point for companion repository work.

# systems_thinking_organizations_learning_workflow.py
# Dependency-light workflow for organizational learning diagnostics:
# workload-capacity dynamics, feedback signal distortion, institutional memory,
# burnout risk, local optimization, voice, and learning redesign scenarios.
# Writes outputs relative to the article root.

from __future__ import annotations

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

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


@dataclass
class OrganizationalLearningScenario:
    name: str
    workload_growth: float
    capacity_investment: float
    recovery_protection: float
    feedback_quality: float
    signal_distortion: float
    institutional_memory_practice: float
    turnover_pressure: float
    local_optimization_pressure: float
    cross_boundary_accountability: float
    psychological_safety: float
    affected_voice: float
    redesign_authority: float


def clamp(value: float, low: float = 0.0, high: float = 140.0) -> float:
    return max(low, min(high, value))


def run_scenario(scenario: OrganizationalLearningScenario, periods: int = 64) -> list[dict[str, object]]:
    workload = 58.0 + scenario.workload_growth * 14.0
    capacity = 48.0 + scenario.capacity_investment * 18.0
    burnout_risk = 34.0 + scenario.turnover_pressure * 16.0
    institutional_memory = 36.0 + scenario.institutional_memory_practice * 18.0
    feedback_signal = 38.0 + scenario.feedback_quality * 18.0
    trust_and_voice = 38.0 + scenario.psychological_safety * 18.0 + scenario.affected_voice * 8.0
    rework_stock = 30.0 + scenario.local_optimization_pressure * 14.0
    silo_cost = 32.0 + scenario.local_optimization_pressure * 18.0
    learning_capacity = 34.0 + scenario.redesign_authority * 16.0
    rows: list[dict[str, object]] = []

    for period in range(periods + 1):
        work_inflow = clamp(
            scenario.workload_growth * 16.0
            + max(0.0, 55.0 - capacity) * 0.10
            + rework_stock * 0.07
            + silo_cost * 0.05,
            0.0,
            100.0,
        )

        work_completion = clamp(
            capacity * 0.18
            + institutional_memory * 0.06
            + learning_capacity * 0.05
            - burnout_risk * 0.08
            - rework_stock * 0.05,
            0.0,
            100.0,
        )

        feedback_distortion = clamp(
            scenario.signal_distortion * 16.0
            + max(0.0, 55.0 - trust_and_voice) * 0.12
            + scenario.local_optimization_pressure * 8.0
            - scenario.psychological_safety * 5.0
            - scenario.affected_voice * 4.0,
            0.0,
            100.0,
        )

        usable_feedback = clamp(
            scenario.feedback_quality * 18.0
            + trust_and_voice * 0.10
            + scenario.affected_voice * 8.0
            + scenario.redesign_authority * 8.0
            - feedback_distortion * 0.20,
            0.0,
            100.0,
        )

        learning_flow = clamp(
            usable_feedback * 0.14
            + scenario.institutional_memory_practice * 12.0
            + scenario.redesign_authority * 10.0
            + scenario.cross_boundary_accountability * 7.0
            - scenario.signal_distortion * 4.0,
            0.0,
            100.0,
        )

        forgetting_flow = clamp(
            scenario.turnover_pressure * 12.0
            + burnout_risk * 0.08
            + max(0.0, workload - capacity) * 0.08
            - scenario.institutional_memory_practice * 5.0
            - scenario.recovery_protection * 3.0,
            0.0,
            100.0,
        )

        local_optimization_cost = clamp(
            scenario.local_optimization_pressure * 16.0
            + max(0.0, silo_cost - 40.0) * 0.10
            - scenario.cross_boundary_accountability * 6.0
            - scenario.redesign_authority * 3.0,
            0.0,
            100.0,
        )

        burnout_flow = clamp(
            max(0.0, workload - capacity) * 0.16
            + rework_stock * 0.06
            + scenario.turnover_pressure * 10.0
            - scenario.recovery_protection * 9.0
            - scenario.capacity_investment * 3.0,
            0.0,
            100.0,
        )

        redesign_flow = clamp(
            scenario.redesign_authority * 16.0
            + scenario.cross_boundary_accountability * 10.0
            + scenario.capacity_investment * 9.0
            + scenario.feedback_quality * 7.0
            + scenario.affected_voice * 7.0
            + scenario.psychological_safety * 6.0,
            0.0,
            100.0,
        )

        workload = clamp(
            workload
            + work_inflow * 0.12
            + rework_stock * 0.04
            - work_completion * 0.10
            - redesign_flow * 0.05,
            0.0,
            140.0,
        )

        capacity = clamp(
            capacity
            + scenario.capacity_investment * 1.5
            + learning_flow * 0.08
            + redesign_flow * 0.05
            - burnout_flow * 0.08
            - scenario.turnover_pressure * 0.8,
            0.0,
            120.0,
        )

        burnout_risk = clamp(
            burnout_risk
            + burnout_flow * 0.12
            + max(0.0, workload - capacity) * 0.04
            - scenario.recovery_protection * 1.6
            - scenario.capacity_investment * 0.8,
            0.0,
            100.0,
        )

        institutional_memory = clamp(
            institutional_memory
            + learning_flow * 0.10
            + scenario.institutional_memory_practice * 1.2
            - forgetting_flow * 0.11,
            0.0,
            120.0,
        )

        feedback_signal = clamp(
            feedback_signal
            + usable_feedback * 0.08
            + scenario.feedback_quality * 1.0
            - feedback_distortion * 0.08,
            0.0,
            100.0,
        )

        trust_and_voice = clamp(
            trust_and_voice
            + scenario.psychological_safety * 1.3
            + scenario.affected_voice * 1.2
            + redesign_flow * 0.04
            - burnout_risk * 0.035
            - feedback_distortion * 0.035,
            0.0,
            100.0,
        )

        rework_stock = clamp(
            rework_stock
            + local_optimization_cost * 0.10
            + max(0.0, workload - capacity) * 0.05
            - redesign_flow * 0.07
            - learning_flow * 0.05,
            0.0,
            120.0,
        )

        silo_cost = clamp(
            silo_cost
            + local_optimization_cost * 0.09
            - scenario.cross_boundary_accountability * 1.5
            - scenario.redesign_authority * 0.8,
            0.0,
            120.0,
        )

        learning_capacity = clamp(
            learning_capacity
            + learning_flow * 0.09
            + scenario.redesign_authority * 1.2
            + scenario.affected_voice * 0.8
            - feedback_distortion * 0.05
            - forgetting_flow * 0.04,
            0.0,
            100.0,
        )

        overload_index = clamp(
            max(0.0, workload - capacity) * 0.25
            + burnout_risk * 0.20
            + rework_stock * 0.16
            + silo_cost * 0.14
            + forgetting_flow * 0.12
            - recovery_protection_score(scenario) * 0.10,
            0.0,
            100.0,
        )

        organizational_learning_score = clamp(
            capacity * 0.16
            + institutional_memory * 0.16
            + feedback_signal * 0.14
            + trust_and_voice * 0.16
            + learning_capacity * 0.16
            + scenario.redesign_authority * 10.0
            + scenario.cross_boundary_accountability * 8.0
            - overload_index * 0.16
            - burnout_risk * 0.15
            - silo_cost * 0.12,
            0.0,
            100.0,
        )

        rows.append({
            "period": period,
            "scenario": scenario.name,
            "workload": round(workload, 3),
            "capacity": round(capacity, 3),
            "burnout_risk": round(burnout_risk, 3),
            "institutional_memory": round(institutional_memory, 3),
            "feedback_signal": round(feedback_signal, 3),
            "trust_and_voice": round(trust_and_voice, 3),
            "rework_stock": round(rework_stock, 3),
            "silo_cost": round(silo_cost, 3),
            "learning_capacity": round(learning_capacity, 3),
            "usable_feedback": round(usable_feedback, 3),
            "feedback_distortion": round(feedback_distortion, 3),
            "learning_flow": round(learning_flow, 3),
            "forgetting_flow": round(forgetting_flow, 3),
            "local_optimization_cost": round(local_optimization_cost, 3),
            "overload_index": round(overload_index, 3),
            "organizational_learning_score": round(organizational_learning_score, 3),
        })

    return rows


def recovery_protection_score(scenario: OrganizationalLearningScenario) -> float:
    return clamp(
        scenario.recovery_protection * 50.0
        + scenario.capacity_investment * 25.0
        + scenario.redesign_authority * 25.0,
        0.0,
        100.0,
    )


def summarize(rows: list[dict[str, object]]) -> list[dict[str, object]]:
    output: list[dict[str, object]] = []
    for scenario_name in sorted({row["scenario"] for row in rows}):
        subset = [row for row in rows if row["scenario"] == scenario_name]
        final = subset[-1]
        avg_learning = mean(float(row["organizational_learning_score"]) for row in subset)
        avg_overload = mean(float(row["overload_index"]) for row in subset)
        avg_burnout = mean(float(row["burnout_risk"]) for row in subset)
        avg_memory = mean(float(row["institutional_memory"]) for row in subset)
        avg_distortion = mean(float(row["feedback_distortion"]) for row in subset)

        if float(final["organizational_learning_score"]) >= 65 and float(final["overload_index"]) <= 35:
            diagnostic = "learning redesign is building capacity, memory, and usable feedback"
        elif avg_overload >= 55 and avg_burnout >= 55:
            diagnostic = "overload and burnout are dominating organizational behavior"
        elif avg_distortion >= 55:
            diagnostic = "feedback distortion is blocking organizational learning"
        elif avg_memory < 45:
            diagnostic = "institutional memory remains too weak to preserve learning"
        elif avg_learning >= 55:
            diagnostic = "partial learning redesign with remaining overload risk"
        else:
            diagnostic = "weak evidence of durable organizational learning"

        output.append({
            "scenario": scenario_name,
            "final_organizational_learning_score": final["organizational_learning_score"],
            "final_overload_index": final["overload_index"],
            "final_workload": final["workload"],
            "final_capacity": final["capacity"],
            "final_burnout_risk": final["burnout_risk"],
            "final_institutional_memory": final["institutional_memory"],
            "final_feedback_signal": final["feedback_signal"],
            "average_organizational_learning_score": round(avg_learning, 3),
            "average_overload_index": round(avg_overload, 3),
            "average_burnout_risk": round(avg_burnout, 3),
            "average_institutional_memory": round(avg_memory, 3),
            "average_feedback_distortion": round(avg_distortion, 3),
            "diagnostic": diagnostic,
        })

    return output


def one_at_a_time(base: OrganizationalLearningScenario, delta: float = 0.10) -> list[dict[str, object]]:
    base_score = float(run_scenario(base)[-1]["organizational_learning_score"])
    parameters = [
        "workload_growth",
        "capacity_investment",
        "recovery_protection",
        "feedback_quality",
        "signal_distortion",
        "institutional_memory_practice",
        "turnover_pressure",
        "local_optimization_pressure",
        "cross_boundary_accountability",
        "psychological_safety",
        "affected_voice",
        "redesign_authority",
    ]

    rows: list[dict[str, object]] = []
    for parameter in parameters:
        for direction in (-1, 1):
            current = getattr(base, parameter)
            revised_value = max(0.0, min(1.0, current + direction * delta))
            revised = replace(base, name=f"{base.name} {parameter} {direction * delta:+.2f}", **{parameter: revised_value})
            revised_score = float(run_scenario(revised)[-1]["organizational_learning_score"])
            rows.append({
                "parameter": parameter,
                "delta": direction * delta,
                "base_value": current,
                "revised_value": revised_value,
                "base_final_organizational_learning_score": round(base_score, 3),
                "revised_final_organizational_learning_score": round(revised_score, 3),
                "score_change": round(revised_score - base_score, 3),
                "absolute_score_change": round(abs(revised_score - base_score), 3),
            })

    return sorted(rows, key=lambda row: float(row["absolute_score_change"]), reverse=True)


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:
    scenarios = [
        OrganizationalLearningScenario("Pressure without learning", 0.78, 0.24, 0.18, 0.30, 0.72, 0.24, 0.68, 0.72, 0.24, 0.22, 0.20, 0.22),
        OrganizationalLearningScenario("Dashboard and training reform", 0.66, 0.38, 0.30, 0.58, 0.54, 0.38, 0.56, 0.58, 0.36, 0.34, 0.32, 0.36),
        OrganizationalLearningScenario("Feedback and memory redesign", 0.52, 0.66, 0.62, 0.72, 0.34, 0.72, 0.36, 0.36, 0.68, 0.66, 0.66, 0.68),
        OrganizationalLearningScenario("Learning organization redesign", 0.42, 0.82, 0.82, 0.84, 0.22, 0.84, 0.24, 0.24, 0.84, 0.84, 0.86, 0.86),
    ]

    rows: list[dict[str, object]] = []
    for scenario in scenarios:
        rows.extend(run_scenario(scenario))

    write_csv(TABLES / "organizational_learning_timeseries.csv", rows)
    write_csv(TABLES / "organizational_learning_summary.csv", summarize(rows))
    write_csv(TABLES / "organizational_learning_sensitivity_analysis.csv", one_at_a_time(scenarios[-1]))

    print("Organizational learning workflow complete.")
    print(TABLES / "organizational_learning_timeseries.csv")


if __name__ == "__main__":
    main()

The workflow is intentionally simple enough to inspect. It shows how workload, capacity, recovery, feedback quality, signal distortion, institutional memory, turnover pressure, local optimization, cross-boundary accountability, psychological safety, affected voice, and redesign authority interact over time. It also shows why activity, dashboards, and training do not prove learning if overload, forgetting, and signal distortion continue. The model is synthetic and illustrative; it supports disciplined inquiry rather than replacing domain expertise, stakeholder evidence, or ethical judgment.

Back to top ↑

R Workflow: Organizational Learning Summary and Capacity-Scenario Visualization

The R workflow reads the Python-generated time-series and sensitivity outputs, creates scenario summaries, and exports base R plots for workload, capacity, burnout risk, institutional memory, feedback distortion, and organizational learning score. It uses only base R so it remains portable across simple local environments.

# systems_thinking_organizations_learning_diagnostics.R
# Base R workflow for organizational learning summary and capacity-scenario visualization.

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)
}

timeseries_path <- file.path(tables_dir, "organizational_learning_timeseries.csv")
sensitivity_path <- file.path(tables_dir, "organizational_learning_sensitivity_analysis.csv")

if (!file.exists(timeseries_path)) {
  stop(paste("Missing", timeseries_path, "Run the Python workflow first."))
}

data <- read.csv(timeseries_path, stringsAsFactors = FALSE)

last_by_scenario <- do.call(
  rbind,
  lapply(split(data, data$scenario), function(df) df[nrow(df), ])
)

avg_learning <- aggregate(organizational_learning_score ~ scenario, data = data, FUN = mean)
avg_overload <- aggregate(overload_index ~ scenario, data = data, FUN = mean)
avg_burnout <- aggregate(burnout_risk ~ scenario, data = data, FUN = mean)
avg_memory <- aggregate(institutional_memory ~ scenario, data = data, FUN = mean)
avg_distortion <- aggregate(feedback_distortion ~ scenario, data = data, FUN = mean)

names(avg_learning)[2] <- "average_organizational_learning_score"
names(avg_overload)[2] <- "average_overload_index"
names(avg_burnout)[2] <- "average_burnout_risk"
names(avg_memory)[2] <- "average_institutional_memory"
names(avg_distortion)[2] <- "average_feedback_distortion"

final_fields <- last_by_scenario[, c(
  "scenario",
  "organizational_learning_score",
  "overload_index",
  "workload",
  "capacity",
  "burnout_risk",
  "institutional_memory",
  "feedback_signal"
)]

names(final_fields) <- c(
  "scenario",
  "final_organizational_learning_score",
  "final_overload_index",
  "final_workload",
  "final_capacity",
  "final_burnout_risk",
  "final_institutional_memory",
  "final_feedback_signal"
)

summary_table <- Reduce(
  function(x, y) merge(x, y, by = "scenario"),
  list(avg_learning, avg_overload, avg_burnout, avg_memory, avg_distortion, final_fields)
)

summary_table$diagnostic <- ifelse(
  summary_table$final_organizational_learning_score >= 65 &
    summary_table$final_overload_index <= 35,
  "learning redesign is building capacity, memory, and usable feedback",
  ifelse(
    summary_table$average_overload_index >= 55 &
      summary_table$average_burnout_risk >= 55,
    "overload and burnout are dominating organizational behavior",
    ifelse(
      summary_table$average_feedback_distortion >= 55,
      "feedback distortion is blocking organizational learning",
      ifelse(
        summary_table$average_institutional_memory < 45,
        "institutional memory remains too weak to preserve learning",
        ifelse(
          summary_table$average_organizational_learning_score >= 55,
          "partial learning redesign with remaining overload risk",
          "weak evidence of durable organizational learning"
        )
      )
    )
  )
)

summary_table <- summary_table[order(summary_table$final_organizational_learning_score, decreasing = TRUE), ]

write.csv(
  summary_table,
  file.path(tables_dir, "organizational_learning_r_summary.csv"),
  row.names = FALSE
)

if (file.exists(sensitivity_path)) {
  sensitivity <- read.csv(sensitivity_path, stringsAsFactors = FALSE)
  sensitivity_ranked <- sensitivity[order(sensitivity$absolute_score_change, decreasing = TRUE), ]
  write.csv(
    sensitivity_ranked,
    file.path(tables_dir, "organizational_learning_sensitivity_ranked_r.csv"),
    row.names = FALSE
  )
}

plot_metric <- function(metric, label, file_name) {
  png(file.path(figures_dir, file_name), width = 1200, height = 700)
  scenarios <- unique(data$scenario)
  plot(
    NA,
    xlim = range(data$period),
    ylim = range(data[[metric]], na.rm = TRUE),
    xlab = "Period",
    ylab = label,
    main = paste(label, "by Organizational Learning Scenario")
  )
  for (scenario_name in scenarios) {
    subset_data <- data[data$scenario == scenario_name, ]
    lines(subset_data$period, subset_data[[metric]], lwd = 2)
  }
  legend("topleft", legend = scenarios, lwd = 2, cex = 0.8, bty = "n")
  grid()
  dev.off()
}

plot_metric("workload", "Workload", "workload_trajectories.png")
plot_metric("capacity", "Capacity", "capacity_trajectories.png")
plot_metric("burnout_risk", "Burnout risk", "burnout_risk_trajectories.png")
plot_metric("institutional_memory", "Institutional memory", "institutional_memory_trajectories.png")
plot_metric("feedback_distortion", "Feedback distortion", "feedback_distortion_trajectories.png")
plot_metric("organizational_learning_score", "Organizational learning score", "organizational_learning_score_trajectories.png")

png(file.path(figures_dir, "final_organizational_learning_scores.png"), width = 1200, height = 700)
barplot(
  summary_table$final_organizational_learning_score,
  names.arg = summary_table$scenario,
  las = 2,
  ylab = "Final organizational learning score",
  main = "Final Organizational Learning Score by Scenario"
)
grid()
dev.off()

print(summary_table)

This workflow supports the article’s central methodological claim: organizational learning should be evaluated through behavior over time, not through workshops, dashboards, or policy statements alone. The R outputs help readers compare pressure-based management with feedback, memory, capacity, and redesign-oriented learning systems.

Back to top ↑

GitHub Repository

The companion repository for this article should help readers model organizational learning, feedback loops, workload-capacity dynamics, institutional memory, signal distortion, silos, burnout, and structural redesign scenarios using synthetic datasets and reproducible workflows.

articles/systems-thinking-in-organizations-and-learning/
├── python/
│   ├── systems_thinking_organizations_learning_workflow.py
│   ├── organizational_learning_baseline.py
│   ├── workload_capacity_model.py
│   ├── burnout_feedback_simulation.py
│   ├── institutional_memory_decay.py
│   ├── feedback_signal_distortion.py
│   ├── local_optimization_model.py
│   ├── information_flow_network.py
│   ├── learning_redesign_scenarios.py
│   ├── validation_checks.py
│   └── run_all_organizational_learning_workflows.py
├── r/
│   ├── systems_thinking_organizations_learning_diagnostics.R
│   ├── organizational_learning_plots.R
│   ├── workload_capacity_visualization.R
│   ├── memory_decay_tables.R
│   ├── burnout_risk_summary.R
│   ├── feedback_quality_analysis.R
│   ├── redesign_scenario_comparison.R
│   └── run_all_organizational_learning_workflows.R
├── julia/
│   ├── nonlinear_learning_dynamics.jl
│   ├── capacity_memory_feedback.jl
│   └── organizational_adaptation_model.jl
├── sql/
│   ├── schema_teams.sql
│   ├── schema_workload_events.sql
│   ├── schema_capacity_stocks.sql
│   ├── schema_feedback_signals.sql
│   ├── schema_learning_events.sql
│   ├── schema_memory_assets.sql
│   ├── schema_burnout_indicators.sql
│   ├── schema_redesign_scenarios.sql
│   ├── schema_model_runs.sql
│   └── schema_outputs.sql
├── rust/
│   └── organizational_learning_diagnostics_cli.rs
├── go/
│   └── learning_scenario_runner.go
├── cpp/
│   ├── efficient_capacity_scan.cpp
│   └── feedback_delay_solver.cpp
├── fortran/
│   └── recurrence_learning_memory_model.f90
├── c/
│   └── low_level_org_feedback_engine.c
├── docs/
│   ├── modeling_principles.md
│   ├── article_notes.md
│   ├── organizational_learning_framework.md
│   ├── feedback_and_memory_framework.md
│   ├── diagnostic_questions.md
│   ├── ethics_and_power_notes.md
│   ├── assumptions_and_limitations.md
│   └── responsible_use.md
├── data/
│   ├── synthetic_teams.csv
│   ├── synthetic_workload_events.csv
│   ├── synthetic_capacity_stocks.csv
│   ├── synthetic_feedback_signals.csv
│   ├── synthetic_learning_events.csv
│   ├── synthetic_memory_assets.csv
│   ├── synthetic_burnout_indicators.csv
│   ├── synthetic_redesign_scenarios.csv
│   ├── synthetic_model_runs.csv
│   └── synthetic_outputs.csv
├── outputs/
│   ├── README.md
│   ├── figures/
│   └── tables/
└── notebooks/
    ├── python_organizational_learning_walkthrough.ipynb
    └── r_learning_systems_visualization_placeholder.ipynb

This repository structure supports the article’s central argument: organizational learning depends on feedback, memory, capacity, authority, and system redesign. The data/ folder separates teams, workload events, capacity stocks, feedback signals, learning events, memory assets, burnout indicators, redesign scenarios, model runs, and outputs. The python/ and r/ folders support workload-capacity modeling, burnout feedback simulation, institutional-memory decay, feedback distortion analysis, local optimization, information-flow networks, and learning redesign scenarios. The julia folder supports nonlinear learning dynamics and adaptation models. The sql folder defines schemas for organizational learning data. The lower-level language folders provide scaffolds for diagnostics, capacity scanning, feedback delay solving, recurrence modeling, and low-level simulation.

Back to top ↑

Back to top ↑

Back to top ↑

Why Organizational Learning Requires Systems Thinking

Organizations learn through structure. They learn through feedback, routines, memory, incentives, authority, metrics, culture, and power. They also fail to learn through those same structures. A recurring problem is rarely just a recurring individual mistake. It is often a pattern the organization is producing because its design makes that pattern likely.

Systems thinking helps organizations move beyond shallow explanations. It asks why feedback is late, why routines preserve failure, why metrics distort behavior, why people hide bad news, why silos persist, why burnout becomes normal, why lessons are forgotten, and why change initiatives fade. It asks what the organization must redesign so that learning becomes easier than denial and repair becomes more natural than repetition.

A learning organization is not one that never fails. It is one that can interpret failure without defensiveness, preserve lessons without bureaucracy, change structure without panic, and protect people from carrying the hidden cost of bad design. It treats feedback as a resource, memory as infrastructure, and voice as a condition of intelligence.

Systems thinking in organizations is ultimately a discipline of responsibility. It asks organizations to stop confusing pressure with improvement, activity with learning, and individual endurance with capacity. The organization that learns is the organization willing to be changed by what its own system is trying to tell it.

Back to top ↑

Related Articles

• Policy Resistance and Structural Redesign
• Success to the Successful and Systemic Advantage
• Shifting the Burden
• Fixes That Fail
• Leverage Points and Places to Intervene in a System
• Paradigms, Goals, and Deep System Change
• Mental Models and the Limits of Linear Reasoning
• Systems Thinking in Public Policy

Further Reading

• Senge, Peter M. The Fifth Discipline: The Art and Practice of the Learning Organization. Doubleday/Currency.
• Argyris, Chris and Schön, Donald A. Organizational Learning: A Theory of Action Perspective. Addison-Wesley.
• Argyris, Chris. Overcoming Organizational Defenses: Facilitating Organizational Learning. Allyn and Bacon.
• Edmondson, Amy C. The Fearless Organization: Creating Psychological Safety in the Workplace for Learning, Innovation, and Growth. Wiley.
• March, James G. “Exploration and Exploitation in Organizational Learning.” Organization Science.
• Weick, Karl E. and Sutcliffe, Kathleen M. Managing the Unexpected: Sustained Performance in a Complex World. Wiley.
• Sterman, John D. Business Dynamics: Systems Thinking and Modeling for a Complex World. Irwin/McGraw-Hill.
• Meadows, Donella H. Thinking in Systems: A Primer. Chelsea Green Publishing.
• Nonaka, Ikujiro and Takeuchi, Hirotaka. The Knowledge-Creating Company. Oxford University Press.
• Simon, Herbert A. Administrative Behavior. Free Press.

Back to top ↑

References

• Argyris, C. (1990) Overcoming Organizational Defenses: Facilitating Organizational Learning. Boston: Allyn and Bacon.
• Argyris, C. and Schön, D.A. (1978) Organizational Learning: A Theory of Action Perspective. Reading, MA: Addison-Wesley.
• Edmondson, A.C. (1999) “Psychological Safety and Learning Behavior in Work Teams.” Administrative Science Quarterly, 44(2), pp. 350–383. Available at: https://doi.org/10.2307/2666999
• Edmondson, A.C. (2018) The Fearless Organization: Creating Psychological Safety in the Workplace for Learning, Innovation, and Growth. Hoboken, NJ: Wiley.
• March, J.G. (1991) “Exploration and Exploitation in Organizational Learning.” Organization Science, 2(1), pp. 71–87. Available at: https://doi.org/10.1287/orsc.2.1.71
• Meadows, D.H. (2008) Thinking in Systems: A Primer. White River Junction, VT: Chelsea Green Publishing. Available at: https://www.chelseagreen.com/product/thinking-in-systems/
• Nonaka, I. and Takeuchi, H. (1995) The Knowledge-Creating Company: How Japanese Companies Create the Dynamics of Innovation. New York: Oxford University Press.
• Senge, P.M. (1990) The Fifth Discipline: The Art and Practice of the Learning Organization. New York: Doubleday/Currency.
• Simon, H.A. (1947) Administrative Behavior: A Study of Decision-Making Processes in Administrative Organization. New York: Free Press.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston: Irwin/McGraw-Hill.
• Weick, K.E. and Sutcliffe, K.M. (2007) Managing the Unexpected: Resilient Performance in an Age of Uncertainty. 2nd edn. San Francisco: Jossey-Bass.

Back to top ↑