{
  "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": "Healthcare AI Is Entering Its Platform Phase — and That Changes What Leaders Should Evaluate First",
      "slug": "healthcare-ai-is-entering-its-platform-phase-and-that-change",
      "generated_by": "LinkedIn Post Generator + Azure OpenAI",
      "generated_at": "2026-08-24T16:43:49.720Z"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Healthcare AI Is Entering Its Platform Phase — and That Changes What Leaders Should Evaluate First\n",
        "\n",
        "This notebook turns the article's core argument into hands-on validation exercises. Instead of judging healthcare AI by a polished demo alone, we will test governance-first scoring, policy gates for clinical use, and a simple readiness workflow that leaders can adapt for real evaluation."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "%pip install -q pandas numpy matplotlib"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from pprint import pprint"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Why the unit of evaluation has changed\n",
        "\n",
        "The article argues that healthcare AI should no longer be evaluated as a single feature or model demo. The real unit of evaluation is the deployment stack: data foundation, AI lifecycle, workflow integration, engineering support, security controls, auditability, and measurable outcomes.\n",
        "\n",
        "The first exercise implements a governance-first scoring model. This helps validate the claim that governance and security should outweigh model polish when deciding whether a platform is ready for clinical environments."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# Python: score a healthcare AI platform on governance-first criteria\n",
        "weights = {\n",
        "    \"integration\": 0.20,\n",
        "    \"governance\": 0.30,\n",
        "    \"monitoring\": 0.20,\n",
        "    \"security\": 0.20,\n",
        "    \"workflow_fit\": 0.10,\n",
        "}\n",
        "\n",
        "vendor = {\n",
        "    \"integration\": 8,\n",
        "    \"governance\": 9,\n",
        "    \"monitoring\": 7,\n",
        "    \"security\": 9,\n",
        "    \"workflow_fit\": 6,\n",
        "}\n",
        "\n",
        "score = sum(vendor[k] * w for k, w in weights.items())\n",
        "print(f\"Platform readiness score: {score:.1f}/10\")\n",
        "\n",
        "# Optional validation table\n",
        "score_df = pd.DataFrame({\n",
        "    \"criterion\": list(weights.keys()),\n",
        "    \"weight\": list(weights.values()),\n",
        "    \"vendor_score\": [vendor[k] for k in weights.keys()]\n",
        "})\n",
        "score_df[\"weighted_contribution\"] = score_df[\"weight\"] * score_df[\"vendor_score\"]\n",
        "score_df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Compare multiple vendors using governance-first criteria\n",
        "\n",
        "A single score is useful, but leaders usually compare options. This extension evaluates several hypothetical vendors to show how a platform with stronger governance and security can outrank one with a flashier workflow experience."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "weights = {\n",
        "    \"integration\": 0.20,\n",
        "    \"governance\": 0.30,\n",
        "    \"monitoring\": 0.20,\n",
        "    \"security\": 0.20,\n",
        "    \"workflow_fit\": 0.10,\n",
        "}\n",
        "\n",
        "vendors = {\n",
        "    \"Vendor_A\": {\"integration\": 8, \"governance\": 9, \"monitoring\": 7, \"security\": 9, \"workflow_fit\": 6},\n",
        "    \"Vendor_B\": {\"integration\": 9, \"governance\": 6, \"monitoring\": 6, \"security\": 7, \"workflow_fit\": 9},\n",
        "    \"Vendor_C\": {\"integration\": 7, \"governance\": 8, \"monitoring\": 8, \"security\": 8, \"workflow_fit\": 7},\n",
        "}\n",
        "\n",
        "rows = []\n",
        "for name, scores in vendors.items():\n",
        "    total = sum(scores[k] * weights[k] for k in weights)\n",
        "    row = {\"vendor\": name, **scores, \"platform_readiness_score\": round(total, 2)}\n",
        "    rows.append(row)\n",
        "\n",
        "comparison_df = pd.DataFrame(rows).sort_values(\"platform_readiness_score\", ascending=False)\n",
        "print(comparison_df.to_string(index=False))\n",
        "\n",
        "ax = comparison_df.plot(x=\"vendor\", y=\"platform_readiness_score\", kind=\"bar\", legend=False, figsize=(8, 4), color=\"steelblue\")\n",
        "ax.set_ylabel(\"Score / 10\")\n",
        "ax.set_title(\"Governance-First Platform Readiness Comparison\")\n",
        "plt.xticks(rotation=0)\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Policy gate before clinical use\n",
        "\n",
        "The article stresses that general availability does not equal clinical readiness. A model should not enter care workflows unless required controls are in place.\n",
        "\n",
        "This example implements a simple approval gate. It checks for core deployment safeguards such as PHI controls, audit logs, drift monitoring, and human review."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# Python: simple policy gate before a model can be used in care workflows\n",
        "def approve_for_clinical_use(model):\n",
        "    required = [\"phi_controls\", \"audit_logs\", \"drift_monitoring\", \"human_review\"]\n",
        "    missing = [item for item in required if not model.get(item)]\n",
        "    return {\"approved\": not missing, \"missing\": missing}\n",
        "\n",
        "candidate = {\n",
        "    \"name\": \"triage-assistant-v2\",\n",
        "    \"phi_controls\": True,\n",
        "    \"audit_logs\": True,\n",
        "    \"drift_monitoring\": False,\n",
        "    \"human_review\": True,\n",
        "}\n",
        "\n",
        "print(approve_for_clinical_use(candidate))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Validate multiple candidates against the policy gate\n",
        "\n",
        "To make the policy gate more practical, this cell tests several hypothetical AI applications. This mirrors a reusable intake process where every proposal must pass the same governance and safety checks before moving beyond exploration."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "def approve_for_clinical_use(model):\n",
        "    required = [\"phi_controls\", \"audit_logs\", \"drift_monitoring\", \"human_review\"]\n",
        "    missing = [item for item in required if not model.get(item)]\n",
        "    return {\"approved\": not missing, \"missing\": missing}\n",
        "\n",
        "candidates = [\n",
        "    {\n",
        "        \"name\": \"triage-assistant-v2\",\n",
        "        \"phi_controls\": True,\n",
        "        \"audit_logs\": True,\n",
        "        \"drift_monitoring\": False,\n",
        "        \"human_review\": True,\n",
        "    },\n",
        "    {\n",
        "        \"name\": \"radiology-draft-helper\",\n",
        "        \"phi_controls\": True,\n",
        "        \"audit_logs\": True,\n",
        "        \"drift_monitoring\": True,\n",
        "        \"human_review\": True,\n",
        "    },\n",
        "    {\n",
        "        \"name\": \"discharge-summary-bot\",\n",
        "        \"phi_controls\": False,\n",
        "        \"audit_logs\": True,\n",
        "        \"drift_monitoring\": True,\n",
        "        \"human_review\": False,\n",
        "    },\n",
        "]\n",
        "\n",
        "results = []\n",
        "for model in candidates:\n",
        "    decision = approve_for_clinical_use(model)\n",
        "    results.append({\n",
        "        \"name\": model[\"name\"],\n",
        "        \"approved\": decision[\"approved\"],\n",
        "        \"missing_controls\": \", \".join(decision[\"missing\"]) if decision[\"missing\"] else \"None\"\n",
        "    })\n",
        "\n",
        "results_df = pd.DataFrame(results)\n",
        "results_df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Translate the enterprise checklist into Python\n",
        "\n",
        "The original post included a PowerShell checklist for enterprise readiness. Because this notebook uses Python, the same idea is implemented here as a simple dictionary-based checklist.\n",
        "\n",
        "This helps validate whether a proposed healthcare AI platform has the minimum operational capabilities leaders should ask about first."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "checks = {\n",
        "    \"EHR/FHIR Integration\": True,\n",
        "    \"Audit Logging\": True,\n",
        "    \"PHI Safeguards\": True,\n",
        "    \"Model Monitoring\": False,\n",
        "    \"Human-in-the-Loop\": True,\n",
        "}\n",
        "\n",
        "for name in sorted(checks):\n",
        "    status = \"OK\" if checks[name] else \"GAP\"\n",
        "    print(f\"{name}: {status}\")\n",
        "\n",
        "checklist_df = pd.DataFrame([\n",
        "    {\"check\": name, \"status\": \"OK\" if value else \"GAP\"}\n",
        "    for name, value in sorted(checks.items())\n",
        "])\n",
        "checklist_df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Score organizational readiness from 1 to 5\n",
        "\n",
        "The article ends by asking whether organizations are scoring the model first or the operating system around it. This exercise converts that question into a simple maturity assessment across platform layers.\n",
        "\n",
        "A higher score here reflects stronger operational readiness, not just better model performance."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "readiness = {\n",
        "    \"data_foundation\": 4,\n",
        "    \"ai_lifecycle\": 3,\n",
        "    \"workflow_integration\": 3,\n",
        "    \"engineering_support\": 2,\n",
        "    \"security_architecture\": 4,\n",
        "    \"auditability\": 3,\n",
        "    \"safety_review\": 2,\n",
        "    \"measurable_outcomes\": 3,\n",
        "}\n",
        "\n",
        "readiness_df = pd.DataFrame({\n",
        "    \"domain\": list(readiness.keys()),\n",
        "    \"score_1_to_5\": list(readiness.values())\n",
        "})\n",
        "\n",
        "overall = readiness_df[\"score_1_to_5\"].mean()\n",
        "print(f\"Overall healthcare AI platform readiness: {overall:.2f}/5\")\n",
        "readiness_df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Visualize where the gaps are\n",
        "\n",
        "A readiness average can hide weak points. This chart makes it easier to see where governance, workflow, engineering, or safety gaps could block deployment in month 9 even if a demo looked strong on day 1."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "readiness = {\n",
        "    \"data_foundation\": 4,\n",
        "    \"ai_lifecycle\": 3,\n",
        "    \"workflow_integration\": 3,\n",
        "    \"engineering_support\": 2,\n",
        "    \"security_architecture\": 4,\n",
        "    \"auditability\": 3,\n",
        "    \"safety_review\": 2,\n",
        "    \"measurable_outcomes\": 3,\n",
        "}\n",
        "\n",
        "readiness_df = pd.DataFrame({\n",
        "    \"domain\": list(readiness.keys()),\n",
        "    \"score_1_to_5\": list(readiness.values())\n",
        "}).sort_values(\"score_1_to_5\")\n",
        "\n",
        "ax = readiness_df.plot(x=\"domain\", y=\"score_1_to_5\", kind=\"barh\", legend=False, figsize=(8, 5), color=\"darkgreen\")\n",
        "ax.set_xlabel(\"Readiness Score (1-5)\")\n",
        "ax.set_ylabel(\"Domain\")\n",
        "ax.set_title(\"Healthcare AI Platform Readiness by Domain\")\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Bounded workflows are better than generic demos\n",
        "\n",
        "The article highlights radiology as a better example than a generic AI demo because the workflow is bounded, users are known, and review patterns are clearer. This final exercise compares a few bounded workflows using deployment criteria rather than feature excitement."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "workflow_candidates = [\n",
        "    {\n",
        "        \"workflow\": \"Radiology reporting\",\n",
        "        \"bounded_workflow\": 5,\n",
        "        \"review_clarity\": 5,\n",
        "        \"auditability\": 4,\n",
        "        \"integration_feasibility\": 4,\n",
        "        \"outcome_measurability\": 5,\n",
        "    },\n",
        "    {\n",
        "        \"workflow\": \"ED triage assistant\",\n",
        "        \"bounded_workflow\": 2,\n",
        "        \"review_clarity\": 2,\n",
        "        \"auditability\": 3,\n",
        "        \"integration_feasibility\": 3,\n",
        "        \"outcome_measurability\": 3,\n",
        "    },\n",
        "    {\n",
        "        \"workflow\": \"Discharge summaries\",\n",
        "        \"bounded_workflow\": 4,\n",
        "        \"review_clarity\": 4,\n",
        "        \"auditability\": 4,\n",
        "        \"integration_feasibility\": 3,\n",
        "        \"outcome_measurability\": 4,\n",
        "    },\n",
        "]\n",
        "\n",
        "workflow_df = pd.DataFrame(workflow_candidates)\n",
        "criteria = [\"bounded_workflow\", \"review_clarity\", \"auditability\", \"integration_feasibility\", \"outcome_measurability\"]\n",
        "workflow_df[\"deployment_priority_score\"] = workflow_df[criteria].mean(axis=1).round(2)\n",
        "workflow_df = workflow_df.sort_values(\"deployment_priority_score\", ascending=False)\n",
        "workflow_df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Summary\n",
        "\n",
        "This notebook validated the article's main thesis with simple, reusable checks: governance-first scoring, clinical-use policy gates, enterprise readiness checklists, and bounded workflow prioritization. The exercises show why healthcare AI leaders should evaluate platform layers, controls, and accountability before getting distracted by a compelling demo.\n",
        "\n",
        "## Next Steps\n",
        "\n",
        "1. Replace the sample scores with your organization's real criteria and owners.\n",
        "2. Add local thresholds for auditability, human review, and safety escalation.\n",
        "3. Pilot only two or three bounded workflows and require measurable outcomes before expansion.\n",
        "4. Standardize one intake and evaluation process for copilots, agents, and AI apps."
      ]
    }
  ]
}