{
  "nbformat": 4,
  "nbformat_minor": 5,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.13.0"
    },
    "blog_metadata": {
      "topic": "There is no enterprise Copilot without change management — and the best proof is coming from the field",
      "slug": "there-is-no-enterprise-copilot-without-change-management-and",
      "generated_by": "LinkedIn Post Generator + Azure OpenAI",
      "generated_at": "2026-08-02T19:41:44.153Z"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# There is no enterprise Copilot without change management — and the best proof is coming from the field\n",
        "\n",
        "This notebook turns the blog post into a hands-on validation workbook. It focuses on the core claim: enterprise Copilot value is not proven by licenses, training attendance, or aggregate usage, but by measurable workflow improvement with clear ownership, exception handling, and sustained adoption.\n",
        "\n",
        "You will walk through lightweight Python examples that simulate baseline adoption, cohort segmentation, role-level adoption analysis, champion coverage, feedback prioritization, ROI signals, and workflow evidence scoring."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "%pip install pandas matplotlib seaborn"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "from dataclasses import dataclass\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "sns.set_theme(style='whitegrid')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Framing the executive problem\n",
        "\n",
        "The blog argues that a rise in Copilot usage without throughput improvement is a warning sign. The real test is whether a named workflow became faster, cleaner, and more reliable, and whether the change held over time.\n",
        "\n",
        "Use the checklist below to anchor validation discussions."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "executive_questions = [\n",
        "    'Which workflow was redesigned?',\n",
        "    'Who owns the decision and the exceptions?',\n",
        "    'What changed for frontline employees on Tuesday morning?',\n",
        "    'Which KPI moved?',\n",
        "    'What evidence proves the change held for more than two weeks?'\n",
        "]\n",
        "\n",
        "for i, q in enumerate(executive_questions, start=1):\n",
        "    print(f'{i}. {q}')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Baseline adoption metrics before rollout\n",
        "\n",
        "This example reproduces the blog's point that training coverage and weekly active usage are only starting signals. They help measure readiness, but they do not prove realized business value."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "from dataclasses import dataclass\n",
        "\n",
        "@dataclass\n",
        "class AdoptionBaseline:\n",
        "    eligible_users: int\n",
        "    trained_users: int\n",
        "    weekly_active_users: int\n",
        "\n",
        "baseline = AdoptionBaseline(\n",
        "    eligible_users=1200,\n",
        "    trained_users=180,\n",
        "    weekly_active_users=95,\n",
        ")\n",
        "\n",
        "training_rate = baseline.trained_users / baseline.eligible_users\n",
        "wau_rate = baseline.weekly_active_users / baseline.eligible_users\n",
        "\n",
        "print(f'Training coverage: {training_rate:.1%}')\n",
        "print(f'Weekly active usage: {wau_rate:.1%}')\n",
        "\n",
        "baseline_df = pd.DataFrame([\n",
        "    {'metric': 'Eligible users', 'value': baseline.eligible_users},\n",
        "    {'metric': 'Trained users', 'value': baseline.trained_users},\n",
        "    {'metric': 'Weekly active users', 'value': baseline.weekly_active_users},\n",
        "    {'metric': 'Training coverage', 'value': training_rate},\n",
        "    {'metric': 'WAU rate', 'value': wau_rate},\n",
        "])\n",
        "\n",
        "baseline_df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Visualize why adoption metrics are weak evidence of value\n",
        "\n",
        "A simple chart makes the point clearer: readiness metrics can look acceptable while workflow KPIs remain unchanged. This is the gap change management must close."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "plot_df = pd.DataFrame({\n",
        "    'metric': ['Training coverage', 'WAU rate'],\n",
        "    'rate': [training_rate, wau_rate]\n",
        "})\n",
        "\n",
        "ax = sns.barplot(data=plot_df, x='metric', y='rate', palette='Blues_d')\n",
        "ax.set_ylim(0, 1)\n",
        "ax.set_ylabel('Rate')\n",
        "ax.set_xlabel('')\n",
        "ax.set_title('Readiness signals are not proof of workflow value')\n",
        "for i, row in plot_df.iterrows():\n",
        "    ax.text(i, row['rate'] + 0.03, f\"{row['rate']:.1%}\", ha='center')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Workflow KPI reset\n",
        "\n",
        "The blog recommends moving from rollout metrics to workflow-level evidence. The next cell creates a compact scorecard structure that can be used to compare before and after states by workflow."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "workflow_scorecard = pd.DataFrame([\n",
        "    {\n",
        "        'workflow': 'Claims intake summary',\n",
        "        'baseline_cycle_time_min': 42,\n",
        "        'post_cycle_time_min': 29,\n",
        "        'baseline_rework_rate': 0.18,\n",
        "        'post_rework_rate': 0.11,\n",
        "        'baseline_exception_rate': 0.22,\n",
        "        'post_exception_rate': 0.15,\n",
        "    },\n",
        "    {\n",
        "        'workflow': 'Shift handoff package',\n",
        "        'baseline_cycle_time_min': 35,\n",
        "        'post_cycle_time_min': 24,\n",
        "        'baseline_rework_rate': 0.14,\n",
        "        'post_rework_rate': 0.09,\n",
        "        'baseline_exception_rate': 0.19,\n",
        "        'post_exception_rate': 0.12,\n",
        "    }\n",
        "])\n",
        "\n",
        "workflow_scorecard['cycle_time_improvement_pct'] = 1 - (workflow_scorecard['post_cycle_time_min'] / workflow_scorecard['baseline_cycle_time_min'])\n",
        "workflow_scorecard['rework_improvement_pct'] = 1 - (workflow_scorecard['post_rework_rate'] / workflow_scorecard['baseline_rework_rate'])\n",
        "workflow_scorecard['exception_improvement_pct'] = 1 - (workflow_scorecard['post_exception_rate'] / workflow_scorecard['baseline_exception_rate'])\n",
        "\n",
        "workflow_scorecard"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Operating-model change map\n",
        "\n",
        "The original post included a Mermaid flowchart showing how the presence or absence of change management affects outcomes. Since notebook code cells must be valid Python, the next cell represents the same logic as structured data and prints the paths."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "change_paths = {\n",
        "    'No': ['Low adoption', 'Shadow workflows', 'Weak ROI narrative'],\n",
        "    'Yes': ['Role-based enablement', 'Champion network', 'Usage feedback loop', 'Measured business outcomes']\n",
        "}\n",
        "\n",
        "for decision, path in change_paths.items():\n",
        "    print(f'Change management in place? {decision}')\n",
        "    for step in path:\n",
        "        print(f'  -> {step}')\n",
        "    print()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Segment users into change cohorts for targeted enablement\n",
        "\n",
        "The blog used PowerShell to classify users by readiness. Here the same logic is implemented in Python so it can run directly in this notebook.\n",
        "\n",
        "The key lesson is that the real deployment unit is not all licensed users, but the role cohort inside a workflow."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "users = [\n",
        "    {'Name': 'Ava', 'Department': 'Sales', 'License': True, 'ManagerApproved': True},\n",
        "    {'Name': 'Noah', 'Department': 'Finance', 'License': True, 'ManagerApproved': False},\n",
        "    {'Name': 'Mia', 'Department': 'HR', 'License': False, 'ManagerApproved': True},\n",
        "]\n",
        "\n",
        "rows = []\n",
        "for user in users:\n",
        "    if not user['License']:\n",
        "        cohort = 'NotReady'\n",
        "    elif not user['ManagerApproved']:\n",
        "        cohort = 'NeedsManagerAlignment'\n",
        "    else:\n",
        "        cohort = 'ReadyForEnablement'\n",
        "    rows.append({\n",
        "        'Name': user['Name'],\n",
        "        'Department': user['Department'],\n",
        "        'Cohort': cohort\n",
        "    })\n",
        "\n",
        "cohort_df = pd.DataFrame(rows)\n",
        "cohort_df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Cohort distribution by readiness\n",
        "\n",
        "This quick summary helps identify where change friction is likely to appear before broad rollout."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "cohort_counts = cohort_df['Cohort'].value_counts().reset_index()\n",
        "cohort_counts.columns = ['Cohort', 'Count']\n",
        "cohort_counts\n",
        "\n",
        "ax = sns.barplot(data=cohort_counts, x='Cohort', y='Count', palette='Set2')\n",
        "ax.set_title('User readiness cohorts')\n",
        "ax.set_xlabel('')\n",
        "plt.xticks(rotation=15)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Sequence of employee adoption and feedback\n",
        "\n",
        "The source material also included a Mermaid sequence diagram showing how employees, managers, change leads, and metrics interact. The next cell models that sequence as ordered events."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "sequence_events = [\n",
        "    ('Employee', 'Copilot', 'Tries Copilot for daily work'),\n",
        "    ('Copilot', 'Employee', 'Drafts, summaries, actions'),\n",
        "    ('Employee', 'Manager', 'Shares time saved and blockers'),\n",
        "    ('Manager', 'Change Lead', 'Requests role-based guidance'),\n",
        "    ('Change Lead', 'Employee', 'Delivers training + prompt patterns'),\n",
        "    ('Employee', 'Metrics Dashboard', 'Usage and outcome signals'),\n",
        "    ('Metrics Dashboard', 'Change Lead', 'Adoption and ROI trends'),\n",
        "]\n",
        "\n",
        "for sender, receiver, action in sequence_events:\n",
        "    print(f'{sender} -> {receiver}: {action}')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Track adoption by role to prove change management impact\n",
        "\n",
        "This example mirrors the blog's role-level adoption code. It shows why aggregate adoption can hide very different realities across functions."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "usage = [\n",
        "    {'role': 'Sales', 'users': 120, 'active': 84},\n",
        "    {'role': 'HR', 'users': 40, 'active': 18},\n",
        "    {'role': 'Finance', 'users': 60, 'active': 21},\n",
        "]\n",
        "\n",
        "for row in usage:\n",
        "    rate = row['active'] / row['users']\n",
        "    status = 'healthy' if rate >= 0.60 else 'needs enablement'\n",
        "    print(f\"{row['role']}: {rate:.0%} active, status={status}\")\n",
        "\n",
        "usage_df = pd.DataFrame(usage)\n",
        "usage_df['active_rate'] = usage_df['active'] / usage_df['users']\n",
        "usage_df['status'] = usage_df['active_rate'].apply(lambda x: 'healthy' if x >= 0.60 else 'needs enablement')\n",
        "usage_df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Visualize role-level adoption gaps\n",
        "\n",
        "This chart makes it easier to spot where manager reinforcement, training, or workflow redesign is required."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "ax = sns.barplot(data=usage_df, x='role', y='active_rate', hue='status', dodge=False, palette='viridis')\n",
        "ax.set_ylim(0, 1)\n",
        "ax.set_ylabel('Active rate')\n",
        "ax.set_xlabel('Role')\n",
        "ax.set_title('Adoption differs by role, not just overall average')\n",
        "for i, row in usage_df.reset_index().iterrows():\n",
        "    ax.text(i, row['active_rate'] + 0.03, f\"{row['active_rate']:.0%}\", ha='center')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Create a lightweight champion network roster\n",
        "\n",
        "The blog included a PowerShell example for champion coverage. This Python version groups champions by region to show whether support capacity is distributed where adoption work is happening."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "champions = [\n",
        "    {'Name': 'Lena', 'Role': 'Sales Ops', 'Region': 'EMEA'},\n",
        "    {'Name': 'Omar', 'Role': 'HRBP', 'Region': 'NA'},\n",
        "    {'Name': 'Priya', 'Role': 'Finance Manager', 'Region': 'APAC'},\n",
        "]\n",
        "\n",
        "champions_df = pd.DataFrame(champions)\n",
        "champion_summary = (\n",
        "    champions_df.groupby('Region')\n",
        "    .agg(ChampionCount=('Name', 'count'), Champions=('Name', lambda x: ', '.join(x)))\n",
        "    .reset_index()\n",
        ")\n",
        "\n",
        "champion_summary"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Convert field feedback into prioritized change actions\n",
        "\n",
        "This example reflects the blog's recommendation to turn field feedback into a ranked backlog. The point is that interventions should match the blocker, not default to more generic prompt training."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "feedback = [\n",
        "    {'theme': 'Prompting', 'votes': 18},\n",
        "    {'theme': 'Data access confusion', 'votes': 27},\n",
        "    {'theme': 'Manager skepticism', 'votes': 22},\n",
        "]\n",
        "\n",
        "priority = sorted(feedback, key=lambda item: item['votes'], reverse=True)\n",
        "\n",
        "for item in priority:\n",
        "    action = {\n",
        "        'Data access confusion': 'publish governance FAQ',\n",
        "        'Manager skepticism': 'run leader briefing',\n",
        "        'Prompting': 'deliver role-based labs',\n",
        "    }[item['theme']]\n",
        "    print(f\"{item['theme']}: {item['votes']} votes -> {action}\")\n",
        "\n",
        "priority_df = pd.DataFrame(priority)\n",
        "priority_df['action'] = priority_df['theme'].map({\n",
        "    'Data access confusion': 'publish governance FAQ',\n",
        "    'Manager skepticism': 'run leader briefing',\n",
        "    'Prompting': 'deliver role-based labs',\n",
        "})\n",
        "priority_df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Visualize the intervention backlog\n",
        "\n",
        "A ranked chart helps teams focus on the highest-friction blockers first."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "ax = sns.barplot(data=priority_df, x='votes', y='theme', palette='magma')\n",
        "ax.set_title('Ranked blockers from field feedback')\n",
        "ax.set_xlabel('Votes')\n",
        "ax.set_ylabel('Theme')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Measure simple ROI signals from time-saved stories\n",
        "\n",
        "The source material included a PowerShell example for converting anecdotal time savings into monthly hours. This Python version keeps the same intent while reinforcing the blog's warning: these are signals, not full proof of value."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "stories = [\n",
        "    {'Team': 'Sales', 'MinutesSavedPerWeek': 45, 'Users': 80},\n",
        "    {'Team': 'HR', 'MinutesSavedPerWeek': 30, 'Users': 25},\n",
        "    {'Team': 'Finance', 'MinutesSavedPerWeek': 20, 'Users': 35},\n",
        "]\n",
        "\n",
        "roi_rows = []\n",
        "for story in stories:\n",
        "    hours_per_month = (story['MinutesSavedPerWeek'] * story['Users'] * 4) / 60\n",
        "    roi_rows.append({\n",
        "        'Team': story['Team'],\n",
        "        'HoursPerMonth': round(hours_per_month, 1)\n",
        "    })\n",
        "\n",
        "roi_df = pd.DataFrame(roi_rows)\n",
        "roi_df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Compare ROI signals across teams\n",
        "\n",
        "This view is useful for storytelling, but it should be paired with workflow KPIs such as cycle time, rework, and exception resolution."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "ax = sns.barplot(data=roi_df, x='Team', y='HoursPerMonth', palette='crest')\n",
        "ax.set_title('Estimated monthly hours saved by team')\n",
        "ax.set_ylabel('Hours per month')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Continuous improvement loop\n",
        "\n",
        "The blog's second Mermaid flowchart described a weekly operating rhythm: observe blockers, design interventions, support the field, measure outcomes, and either scale or iterate. The next cell encodes that loop as a reusable function."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "def improvement_loop(improvement_visible: bool):\n",
        "    steps = [\n",
        "        'Field observation',\n",
        "        'Identify blocker',\n",
        "        'Design intervention',\n",
        "        'Train managers and champions',\n",
        "        'Support employees in workflow',\n",
        "        'Measure usage and outcomes'\n",
        "    ]\n",
        "    for step in steps:\n",
        "        print(f'-> {step}')\n",
        "    if improvement_visible:\n",
        "        print('-> Scale to next business unit')\n",
        "    else:\n",
        "        print('-> Return to Identify blocker')\n",
        "\n",
        "print('Scenario: improvement visible')\n",
        "improvement_loop(True)\n",
        "print('\\nScenario: improvement not yet visible')\n",
        "improvement_loop(False)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Validate the case-study standard for insurance and dairy\n",
        "\n",
        "The blog set a high bar for field proof. The next cell creates a simple validation template for the two industries discussed: insurance and dairy."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "case_standard = {\n",
        "    'Insurance': [\n",
        "        'named workflow',\n",
        "        'baseline cycle time',\n",
        "        'post-change cycle time over a defined window',\n",
        "        'quality measure',\n",
        "        'exception categories and handoff path',\n",
        "        'active use among the target role',\n",
        "        'accountable process owner',\n",
        "        'frontline enablement plan',\n",
        "        'business outcome tied to the workflow'\n",
        "    ],\n",
        "    'Dairy': [\n",
        "        'named workflow',\n",
        "        'baseline completion time',\n",
        "        'output quality or rework rate',\n",
        "        'exception frequency by plant or shift',\n",
        "        'escalation path for incomplete or unsafe output',\n",
        "        'target-role adoption rate',\n",
        "        'owner for process and owner for platform',\n",
        "        'operating outcome'\n",
        "    ]\n",
        "}\n",
        "\n",
        "for industry, requirements in case_standard.items():\n",
        "    print(industry)\n",
        "    for req in requirements:\n",
        "        print(f'  - {req}')\n",
        "    print()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Score a workflow against the evidence standard\n",
        "\n",
        "This helper lets you test whether a workflow story is a rollout narrative or a real operating-model case."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "required_fields = [\n",
        "    'workflow',\n",
        "    'owner',\n",
        "    'baseline_cycle_time',\n",
        "    'post_cycle_time',\n",
        "    'quality_metric',\n",
        "    'exception_path',\n",
        "    'target_role_adoption',\n",
        "    'human_review_points',\n",
        "    'business_outcome'\n",
        "]\n",
        "\n",
        "sample_workflow = {\n",
        "    'workflow': 'Claims intake summary',\n",
        "    'owner': 'Claims Operations Director',\n",
        "    'baseline_cycle_time': 42,\n",
        "    'post_cycle_time': 29,\n",
        "    'quality_metric': 'QA correction rate',\n",
        "    'exception_path': 'Escalate to senior adjuster for missing evidence',\n",
        "    'target_role_adoption': 0.72,\n",
        "    'human_review_points': 'Adjuster validates summary before submission',\n",
        "    'business_outcome': 'Faster intake and fewer rework loops'\n",
        "}\n",
        "\n",
        "missing = [field for field in required_fields if field not in sample_workflow or sample_workflow[field] in (None, '', [])]\n",
        "score = (len(required_fields) - len(missing)) / len(required_fields)\n",
        "\n",
        "print(f'Evidence score: {score:.0%}')\n",
        "if missing:\n",
        "    print('Missing fields:')\n",
        "    for field in missing:\n",
        "        print(f' - {field}')\n",
        "else:\n",
        "    print('This workflow meets the minimum evidence standard.')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Four failure modes that keep showing up\n",
        "\n",
        "The post identified four recurring problems: unclear ownership, no frontline enablement, governance translated poorly into operations, and treating licenses as realized value. The next cell turns those into a diagnostic table."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "failure_modes = pd.DataFrame([\n",
        "    {\n",
        "        'failure_mode': 'Unclear ownership',\n",
        "        'symptom': 'No one defines success or owns exceptions',\n",
        "        'corrective_action': 'Assign accountable process owner and platform owner'\n",
        "    },\n",
        "    {\n",
        "        'failure_mode': 'No frontline enablement',\n",
        "        'symptom': 'Users have access but lack role-based practice',\n",
        "        'corrective_action': 'Run manager-led workflow labs and reinforcement'\n",
        "    },\n",
        "    {\n",
        "        'failure_mode': 'Governance translated poorly into operations',\n",
        "        'symptom': 'Policies exist but are not embedded in daily procedures',\n",
        "        'corrective_action': 'Define review points, approved data sources, and exception logging'\n",
        "    },\n",
        "    {\n",
        "        'failure_mode': 'Treating licenses as realized value',\n",
        "        'symptom': 'Success is reported through provisioning and MAU only',\n",
        "        'corrective_action': 'Track workflow KPIs and sustained target-role adoption'\n",
        "    }\n",
        "])\n",
        "\n",
        "failure_modes"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## A 90-day field plan\n",
        "\n",
        "The blog closed with a practical rollout plan. The next cell structures that plan into phases that can be reused as a project checklist."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "field_plan = pd.DataFrame([\n",
        "    {\n",
        "        'phase': 'Days 1–15',\n",
        "        'focus': 'Pick the workflows',\n",
        "        'deliverables': 'Select 2 to 4 high-volume, measurable workflows with clear triggers and known exceptions'\n",
        "    },\n",
        "    {\n",
        "        'phase': 'Days 16–30',\n",
        "        'focus': 'Write the workflow charter',\n",
        "        'deliverables': 'Define owner, target role, baseline metrics, review points, exception path, controls, and KPI targets'\n",
        "    },\n",
        "    {\n",
        "        'phase': 'Days 31–45',\n",
        "        'focus': 'Run a controlled cohort',\n",
        "        'deliverables': 'Enable a limited frontline cohort with manager involvement and direct observation'\n",
        "    },\n",
        "    {\n",
        "        'phase': 'Days 46–60',\n",
        "        'focus': 'Redesign based on field evidence',\n",
        "        'deliverables': 'Refine prompts, agent behavior, knowledge access, training, and exception routing'\n",
        "    },\n",
        "    {\n",
        "        'phase': 'Days 61–90',\n",
        "        'focus': 'Review evidence before scaling',\n",
        "        'deliverables': 'Review KPI movement, blockers, governance, and adoption before expanding'\n",
        "    }\n",
        "])\n",
        "\n",
        "field_plan"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Self-assessment: can you prove one workflow improved?\n",
        "\n",
        "The final question in the blog asked leaders to rate their current state from 1 to 5. The next cell provides a simple rubric."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "rubric = {\n",
        "    1: 'No named workflow, no owner, no baseline',\n",
        "    2: 'Workflow identified, but evidence is anecdotal',\n",
        "    3: 'Baseline exists and some adoption is visible, but KPI movement is unclear',\n",
        "    4: 'Workflow KPIs improved with named ownership and exception handling',\n",
        "    5: 'Improvement is sustained, role-level adoption is healthy, and scaling criteria are met'\n",
        "}\n",
        "\n",
        "for score, description in rubric.items():\n",
        "    print(f'{score}: {description}')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Sources referenced in the blog\n",
        "\n",
        "- Microsoft 365 Copilot hub: https://learn.microsoft.com/en-us/microsoft-365/copilot/\n",
        "- Power Platform documentation: https://learn.microsoft.com/en-us/power-platform/\n",
        "- Copilot extensibility prerequisites: https://learn.microsoft.com/en-us/microsoft-365/copilot/extensibility/prerequisites\n",
        "- Agent Builder vs Copilot Studio: https://learn.microsoft.com/en-us/microsoft-365/copilot/extensibility/copilot-studio-experience\n",
        "- Copilot APIs overview: https://learn.microsoft.com/en-us/microsoft-365/copilot/extensibility/copilot-apis-overview\n",
        "- Copilot Cowork FAQ: https://learn.microsoft.com/en-us/microsoft-365/copilot/cowork/cowork-faq\n",
        "- Manage public web access: https://learn.microsoft.com/en-us/microsoft-365/copilot/manage-public-web-access\n",
        "- Agent Builder in Microsoft 365 Copilot: https://learn.microsoft.com/en-us/microsoft-365/copilot/extensibility/agent-builder"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Next Steps\n",
        "\n",
        "Use this notebook as a validation template for a real Copilot deployment. Pick one workflow, assign a named owner, capture baseline metrics, define human review and exception paths, and measure role-level adoption alongside business KPIs.\n",
        "\n",
        "If the evidence shows only activity, not improvement, pause scaling and return to workflow redesign and change management. If the evidence shows sustained gains, you have a field-proof case worth expanding."
      ]
    }
  ]
}