{"data":"<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>CNO Portal — Chief Nursing Officer Leadership Resources</title>
<meta name="description" content="Strategic resources for Chief Nursing Officers and nursing leadership. Staffing models, regulatory guidance, quality benchmarks, and CNO career tools.">
<link rel="canonical" href="https://cnoportal.com">
<script async src="https://www.googletagmanager.com/gtag/js?id=G-XCJWJX8B76"></script>
<script>window.dataLayer=window.dataLayer||[];function gtag(){dataLayer.push(arguments);}gtag('js',new Date());gtag('config','G-XCJWJX8B76');</script>
<style>
:root{
  --navy:#0a1e3c;
  --navy-mid:#14305c;
  --blue:#1a5f9e;
  --blue-light:#2e86c1;
  --silver:#e8f0f8;
  --white:#ffffff;
  --text-dark:#0a1828;
  --text-mid:#2c4a6a;
  --text-light:#5a7a9a;
  --serif:'Georgia',serif;
  --sans:'Helvetica Neue',Arial,sans-serif;
}
*{margin:0;padding:0;box-sizing:border-box;}
body{font-family:var(--sans);color:var(--text-dark);background:var(--white);}
nav{position:fixed;top:0;width:100%;z-index:100;background:rgba(10,30,60,0.97);backdrop-filter:blur(8px);}
.nav-inner{max-width:1100px;margin:0 auto;padding:0 24px;display:flex;align-items:center;justify-content:space-between;height:60px;}
.nav-logo{font-family:var(--serif);color:var(--white);font-size:1.05rem;letter-spacing:0.04em;text-decoration:none;}
.nav-logo span{color:#5dade2;font-size:0.7em;letter-spacing:0.1em;text-transform:uppercase;display:block;font-family:var(--sans);}
.nav-links a{color:rgba(255,255,255,0.75);text-decoration:none;font-size:0.8rem;letter-spacing:0.08em;text-transform:uppercase;margin-left:28px;}
.hero{position:relative;height:84vh;min-height:520px;overflow:hidden;display:flex;align-items:flex-end;}
.hero img{position:absolute;inset:0;width:100%;height:100%;object-fit:cover;opacity:0.82;}
.hero-overlay{position:absolute;inset:0;background:linear-gradient(to top,rgba(10,30,60,0.92) 0%,rgba(10,30,60,0.2) 55%,transparent 100%);}
.hero-content{position:relative;max-width:1100px;margin:0 auto;padding:0 24px 60px;width:100%;}
.hero-badge{display:inline-block;border:1px solid rgba(93,173,226,0.5);color:#5dade2;font-size:0.7rem;letter-spacing:0.12em;text-transform:uppercase;padding:5px 14px;margin-bottom:18px;}
.hero-h1{font-family:var(--serif);color:var(--white);font-size:clamp(1.9rem,4.5vw,2.9rem);line-height:1.22;max-width:640px;margin-bottom:14px;}
.hero-sub{color:rgba(255,255,255,0.78);font-size:0.92rem;max-width:460px;line-height:1.65;margin-bottom:28px;}
.hero-cta{display:inline-block;background:var(--blue);color:var(--white);font-size:0.82rem;font-weight:600;letter-spacing:0.08em;text-transform:uppercase;padding:13px 28px;text-decoration:none;}
.hero-cta:hover{background:var(--blue-light);}
.tool-section{background:var(--silver);padding:76px 24px;}
.tool-inner{max-width:820px;margin:0 auto;}
.sl{font-size:0.7rem;letter-spacing:0.14em;text-transform:uppercase;color:var(--blue);margin-bottom:10px;}
.sh2{font-family:var(--serif);font-size:clamp(1.5rem,3vw,2rem);color:var(--text-dark);margin-bottom:10px;}
.sdesc{color:var(--text-mid);font-size:0.9rem;line-height:1.7;margin-bottom:36px;}
.tool-card{background:var(--white);border:1px solid #c8d8e8;padding:36px;box-shadow:0 2px 12px rgba(10,30,60,0.06);}
.tg{display:grid;grid-template-columns:1fr 1fr;gap:18px;margin-bottom:22px;}
@media(max-width:580px){.tg{grid-template-columns:1fr;}}
.fg label{display:block;font-size:0.75rem;letter-spacing:0.08em;text-transform:uppercase;color:var(--text-mid);font-weight:600;margin-bottom:5px;}
.fg select,.fg input{width:100%;padding:10px 13px;border:1px solid #c8d8e8;font-size:0.88rem;color:var(--text-dark);background:var(--white);}
.calc-btn{width:100%;background:var(--navy);color:var(--white);border:none;padding:13px;font-size:0.85rem;font-weight:600;letter-spacing:0.08em;text-transform:uppercase;cursor:pointer;}
.calc-btn:hover{background:var(--navy-mid);}
.result-panel{display:none;margin-top:24px;background:var(--navy);color:var(--white);padding:28px;}
.result-panel.show{display:block;}
.result-score{font-family:var(--serif);font-size:2.2rem;margin-bottom:4px;}
.result-label{font-size:0.72rem;letter-spacing:0.1em;text-transform:uppercase;opacity:0.6;margin-bottom:14px;}
.result-rec{font-size:0.85rem;line-height:1.7;opacity:0.88;}
.pillars{padding:76px 24px;background:var(--white);}
.pillars-inner{max-width:1100px;margin:0 auto;}
.p-grid{display:grid;grid-template-columns:repeat(3,1fr);gap:24px;margin-top:36px;}
@media(max-width:768px){.p-grid{grid-template-columns:1fr;}}
.p-card{padding:28px;border:1px solid #c8d8e8;border-top:3px solid var(--blue);}
.p-card h3{font-family:var(--serif);font-size:1.05rem;margin-bottom:10px;color:var(--text-dark);}
.p-card p{font-size:0.84rem;line-height:1.65;color:var(--text-mid);}
.newsletter{background:var(--navy);padding:76px 24px;}
.nl-inner{max-width:520px;margin:0 auto;text-align:center;}
.nl-h2{font-family:var(--serif);color:var(--white);font-size:clamp(1.4rem,3vw,1.85rem);margin-bottom:10px;}
.nl-p{color:rgba(255,255,255,0.72);font-size:0.88rem;line-height:1.65;margin-bottom:28px;}
.nl-row{display:flex;gap:8px;flex-wrap:wrap;justify-content:center;}
.nl-row input{flex:1;min-width:200px;padding:12px 16px;border:none;font-size:0.88rem;}
.nl-row button{background:var(--blue);color:var(--white);border:none;padding:12px 20px;font-weight:600;font-size:0.82rem;cursor:pointer;letter-spacing:0.07em;text-transform:uppercase;}
.nl-thanks{display:none;color:#5dade2;font-family:var(--serif);font-size:1.05rem;}
footer{background:#050f20;padding:28px 24px;text-align:center;}
footer p{color:rgba(255,255,255,0.3);font-size:0.75rem;}
footer a{color:rgba(255,255,255,0.4);text-decoration:none;}
</style>
</head>
<body>
<nav>
  <div class="nav-inner">
    <a href="/" class="nav-logo">CNO Portal<span>Chief Nursing Officer Resources</span></a>
    <div class="nav-links">
      <a href="#assessment">Assessment</a>
      <a href="#pillars">Strategy</a>
      <a href="#newsletter">Newsletter</a>
    </div>
  </div>
</nav>
<section class="hero">
  <img src="/hero.jpg" alt="Chief Nursing Officer leadership team in hospital conference room" loading="eager">
  <div class="hero-overlay"></div>
  <div class="hero-content">
    <div class="hero-badge">CNO Leadership Intelligence</div>
    <h1 class="hero-h1">Is your nursing leadership strategy built for 2026?</h1>
    <p class="hero-sub">The CNO role has never faced more pressure: staffing shortfalls, CMS regulatory shifts, and AI-augmented care models. Take the 5-minute readiness assessment.</p>
    <a href="#assessment" class="hero-cta">Take the Assessment</a>
  </div>
</section>
<section class="tool-section" id="assessment">
  <div class="tool-inner">
    <div class="sl">Free Tool</div>
    <h2 class="sh2">CNO Strategy Readiness Assessment</h2>
    <p class="sdesc">Answer five questions about your nursing operations. Receive a readiness score and a prioritized action list for the next 90 days.</p>
    <div class="tool-card">
      <div class="tg">
        <div class="fg"><label>Facility Type</label><select id="facType"><option value="">Select...</option><option value="acute">Acute Care Hospital</option><option value="snf">SNF / Long-Term Care</option><option value="alf">Assisted Living (ALF)</option><option value="health">Health System (multi-site)</option></select></div>
        <div class="fg"><label>Nurse Turnover Rate (annual)</label><select id="turnover"><option value="">Select...</option><option value="low">Under 15%</option><option value="mid">15-25%</option><option value="high">25-40%</option><option value="crisis">40%+</option></select></div>
        <div class="fg"><label>Agency/Travel Nurse Usage</label><select id="agency"><option value="">Select...</option><option value="none">None / minimal</option><option value="low">Under 10% of hours</option><option value="mid">10-25% of hours</option><option value="high">25%+ of hours</option></select></div>
        <div class="fg"><label>CMS Compliance Status</label><select id="cms"><option value="">Select...</option><option value="clean">No deficiencies</option><option value="minor">Minor deficiencies</option><option value="major">Major deficiencies</option><option value="unsure">Unsure / not audited</option></select></div>
        <div class="fg"><label>AI / Tech Adoption Level</label><select id="tech"><option value="">Select...</option><option value="ahead">Ahead of industry</option><option value="avg">Average for our sector</option><option value="behind">Behind industry</option><option value="none">No formal tech strategy</option></select></div>
        <div class="fg"><label>Staff Engagement Score</label><select id="engage"><option value="">Select...</option><option value="top">Top quartile</option><option value="avg">Average</option><option value="low">Below average</option><option value="unknown">Not measured</option></select></div>
      </div>
      <button class="calc-btn" onclick="calcCNO()">Get My Readiness Score</button>
      <div class="result-panel" id="resultPanel">
        <div class="result-score" id="cnoScore">--</div>
        <div class="result-label">CNO Strategy Readiness Score (out of 100)</div>
        <div class="result-rec" id="cnoRec"></div>
      </div>
    </div>
  </div>
</section>
<section class="pillars" id="pillars">
  <div class="pillars-inner">
    <div class="sl">Strategic Pillars</div>
    <h2 style="font-family:var(--serif);font-size:clamp(1.5rem,3vw,2rem);margin-bottom:10px;">The three levers every CNO must pull in 2026</h2>
    <div class="p-grid">
      <div class="p-card"><h3>Staffing Model Redesign</h3><p>The travel nurse arbitrage era is closing. CNOs building durable staffing models are investing in internal float pools, accelerated internal development, and AI-assisted scheduling that reduces agency dependency by 40-60% within 18 months.</p></div>
      <div class="p-card"><h3>CMS Staffing Minimum Rules</h3><p>The CMS minimum nurse staffing rule for LTC facilities (effective 2024-2026 rollout) requires 0.55 RN hours and 2.45 aide hours per resident per day. Most facilities are not compliant. CNOs who missed the planning window are now facing substantial operational disruption.</p></div>
      <div class="p-card"><h3>AI-Augmented Care Models</h3><p>Ambient clinical documentation (AI scribes), predictive deterioration alerts, and AI-assisted medication reconciliation are reducing nursing administrative burden 30-45 minutes per shift in early adopter sites — returning that time to direct patient care.</p></div>
    </div>
  </div>
</section>
<section class="newsletter" id="newsletter">
  <div class="nl-inner">
    <h2 class="nl-h2">The CNO Intelligence Brief</h2>
    <p class="nl-p">Bi-weekly: regulatory updates, staffing benchmarks, technology case studies, and peer CNO perspectives. Written for nursing leaders, not administrators.</p>
    <div class="nl-row" id="nlForm"><input type="email" id="nlEmail" placeholder="your@email.com"><button onclick="nlSub()">Subscribe</button></div>
    <div class="nl-thanks" id="nlThanks">Confirmed. First brief next Tuesday.</div>
  </div>
</section>
<footer><p>&copy; 2026 CNOPortal.com &mdash; <a href="/privacy">Privacy</a> &mdash; Not affiliated with any employer or healthcare system.</p></footer>
<script defer src="/_vercel/insights/script.js"></script>
<script>
function calcCNO(){
  var ft=document.getElementById('facType').value;
  var tv=document.getElementById('turnover').value;
  var ag=document.getElementById('agency').value;
  var cm=document.getElementById('cms').value;
  var tc=document.getElementById('tech').value;
  var eg=document.getElementById('engage').value;
  if(!ft||!tv||!ag||!cm||!tc||!eg){alert('Please answer all questions.');return;}
  var score=100;
  score-={low:0,mid:10,high:22,crisis:35}[tv]||0;
  score-={none:0,low:5,mid:15,high:28}[ag]||0;
  score-={clean:0,minor:10,major:25,unsure:8}[cm]||0;
  score-={ahead:0,avg:5,behind:15,none:25}[tc]||0;
  score-={top:0,avg:8,low:18,unknown:12}[eg]||0;
  score=Math.max(10,score);
  document.getElementById('cnoScore').textContent=score;
  var priorities=[];
  if(tv==='high'||tv==='crisis')priorities.push('Turnover is your #1 priority — focus on internal float pool development and exit interview analysis this quarter');
  if(ag==='high')priorities.push('Agency dependency above 25% is unsustainable at 2026 rates — model a 12-month reduction plan now');
  if(cm==='major')priorities.push('CMS deficiency correction should be an all-hands priority before next survey cycle');
  if(tc==='behind'||tc==='none')priorities.push('AI documentation and scheduling tools have strong ROI at your stage — budget a pilot for Q1');
  if(eg==='low'||eg==='unknown')priorities.push('Implement a quarterly nursing engagement pulse before next planning cycle');
  if(priorities.length===0)priorities.push('Strong across all dimensions. Focus on sustaining compliance and accelerating AI adoption to stay ahead.');
  document.getElementById('cnoRec').textContent='Priority actions: '+priorities.join('. ');
  document.getElementById('resultPanel').classList.add('show');
}
function nlSub(){
  var e=document.getElementById('nlEmail').value;
  if(!e||!e.includes('@')){alert('Enter a valid email.');return;}
  document.getElementById('nlForm').style.display='none';
  document.getElementById('nlThanks').style.display='block';
}
</script>
</body>
</html>"}