AI Readiness Checklist: Six-Dimension Assessment for Enterprise AI

TL;DR — AI readiness assessment prevents 73% of AI failures by identifying gaps before deployment. AI Advisory Practice: "73% of enterprise AI failures trace back to readiness gaps that were knowable before the first dollar was spent. Six dimensions: data, infrastructure, talent, governance, use case viability, culture — each with 5-point scoring and 20+ diagnostic questions." NextAgile: "Most enterprises start with a demo, not a readiness assessment. Then things slow down — the model cannot access clean data, legal gets nervous, teams disagree on ownership." Knowlee: "The output is a decision artifact, not a status report — maps use cases, scores each, classifies build/buy/partner, sequences onto a roadmap." Flywheel: "Strengths in one area do not compensate for weaknesses in another — they compound." Cisco: "Being AI-ready is not about ambition or budget — it is about six critical pillars working together." Internative: "28 questions, 5 dimensions, max score 60. Anything under 40 is a serious gap." Fix order: data first, then governance, infrastructure, talent, in parallel with use case identification. Integrate with change management, governance, compliance, and enterprise TCO.

NextAgile describes the typical failure pattern: "Most enterprises do not start their AI journey with a readiness assessment. They start with a demo. Someone in leadership sees a chatbot summarize reports in 12 seconds. A team experiments with a public LLM. Budget gets approved. A pilot begins. Then things slow down. The model cannot access clean internal knowledge. Legal gets nervous about data exposure. Teams disagree on ownership. Nobody knows which workflows should actually be automated. The pilot works in controlled demos but breaks under real operational conditions. At that point, companies usually assume they picked the wrong model. In practice, the model is rarely the main problem. The real issue is that the organization was never operationally ready for AI deployment."

AI Advisory Practice quantifies the cost: "73% of enterprise AI failures trace back to readiness gaps that were knowable before the first dollar was spent."

AI Readiness Assessment Architecture

Six Dimensions Scoring

28-Question Assessment Framework

Source: Adapted from Internative and AI Advisory Practice

Implementation

from dataclasses import dataclass, field
from typing import Literal

@dataclass
class AIReadinessAssessment:
    """Enterprise AI readiness assessment across six dimensions."""

    # 28 questions, each scored 0-3
    scores: dict = field(default_factory=dict)

    # Dimension weights (default: equal)
    weights = {
        "data": 1.0,
        "process": 1.0,
        "talent": 1.0,
        "culture": 1.0,
        "infrastructure": 1.0,
        "governance": 1.0,
        "use_case": 1.0,
    }

    # Question to dimension mapping
    question_dimensions = {
        1: "data", 2: "data", 3: "data", 4: "data",
        5: "process", 6: "process", 7: "process", 8: "process",
        9: "talent", 10: "talent", 11: "talent", 12: "talent",
        13: "culture", 14: "culture", 15: "culture", 16: "culture",
        17: "infrastructure", 18: "infrastructure",
        19: "infrastructure", 20: "infrastructure",
        21: "governance", 22: "governance",
        23: "governance", 24: "governance",
        25: "use_case", 26: "use_case",
        27: "use_case", 28: "use_case",
    }

    def set_score(self, question_id: int, score: int):
        """Set score for a question (0-3)."""
        assert 0 <= score <= 3, "Score must be 0-3"
        self.scores[question_id] = score

    def calculate_dimension_score(self, dimension: str) -> dict:
        """Calculate score for a single dimension."""
        question_ids = [
            q for q, d in self.question_dimensions.items()
            if d == dimension
        ]
        raw_score = sum(self.scores.get(q, 0) for q in question_ids)
        max_score = len(question_ids) * 3
        percentage = (raw_score / max_score * 100) if max_score > 0 else 0

        # Map to 5-level scale
        if percentage >= 90:
            level = "L5: Optimized"
        elif percentage >= 75:
            level = "L4: Advanced"
        elif percentage >= 50:
            level = "L3: Ready"
        elif percentage >= 25:
            level = "L2: Partial"
        elif percentage > 0:
            level = "L1: Minimal"
        else:
            level = "L0: Not Ready"

        return {
            "dimension": dimension,
            "raw_score": raw_score,
            "max_score": max_score,
            "percentage": round(percentage, 1),
            "level": level,
            "questions": {
                q: self.scores.get(q, 0) for q in question_ids
            },
        }

    def calculate_total_score(self) -> dict:
        """Calculate overall readiness score across all dimensions."""
        dimensions = {}
        weighted_total = 0
        weight_sum = 0

        for dim in self.weights:
            result = self.calculate_dimension_score(dim)
            dimensions[dim] = result
            weighted_total += (
                result["percentage"] * self.weights[dim])
            weight_sum += self.weights[dim]

        overall = weighted_total / weight_sum if weight_sum > 0 else 0

        # Identify weakest factors
        sorted_dims = sorted(
            dimensions.items(),
            key=lambda x: x[1]["percentage"])
        weakest = [
            {"dimension": d, "percentage": v["percentage"],
             "level": v["level"]}
            for d, v in sorted_dims[:3]
        ]

        # Determine if ready for AI strategy execution
        ready = overall >= 66.7  # 2/3 of max

        return {
            "overall_score": round(overall, 1),
            "ready_for_strategy": ready,
            "dimensions": dimensions,
            "weakest_factors": weakest,
            "total_questions": len(self.scores),
            "max_total": 28 * 3,
            "raw_total": sum(self.scores.values()),
        }

    def generate_gap_analysis(self) -> dict:
        """Generate gap analysis with prioritized fixes."""
        total = self.calculate_total_score()

        recommendations = []
        for weak in total["weakest_factors"]:
            dim = weak["dimension"]
            if dim == "data":
                recommendations.append({
                    "dimension": dim,
                    "priority": 1,
                    "action": "Fix data quality and accessibility first. "
                              "Centralize data platform, implement governance, "
                              "establish quality audits.",
                    "timeline": "1-3 months",
                })
            elif dim == "governance":
                recommendations.append({
                    "dimension": dim,
                    "priority": 2,
                    "action": "Establish AI governance framework. "
                              "Appoint AI Risk Officer, create oversight "
                              "processes, map compliance requirements.",
                    "timeline": "1-2 months",
                })
            elif dim == "infrastructure":
                recommendations.append({
                    "dimension": dim,
                    "priority": 3,
                    "action": "Modernize infrastructure. "
                              "Provision GPU capacity, deploy MLOps tools, "
                              "build integration APIs.",
                    "timeline": "2-4 months",
                })
            elif dim == "talent":
                recommendations.append({
                    "dimension": dim,
                    "priority": 4,
                    "action": "Upskill workforce and hire AI talent. "
                              "Launch training programs, hire ML engineers, "
                              "establish domain expertise.",
                    "timeline": "3-6 months",
                })
            elif dim == "culture":
                recommendations.append({
                    "dimension": dim,
                    "priority": 5,
                    "action": "Secure executive sponsorship and budget. "
                              "Identify AI champions, communicate vision, "
                              "allocate dedicated funding.",
                    "timeline": "1-2 months",
                })
            elif dim == "use_case":
                recommendations.append({
                    "dimension": dim,
                    "priority": 6,
                    "action": "Identify and prioritize use cases. "
                              "Map candidate use cases, score impact vs effort, "
                              "classify build/buy/partner.",
                    "timeline": "1-2 months",
                })

        return {
            "overall_score": total["overall_score"],
            "ready_for_strategy": total["ready_for_strategy"],
            "weakest_factors": total["weakest_factors"],
            "recommendations": sorted(
                recommendations, key=lambda x: x["priority"]),
        }

AI Readiness Checklist

• [ ] Conduct AI readiness assessment before any AI deployment
• [ ] Score all six dimensions: data, infrastructure, talent, governance, use case, culture
• [ ] Use 5-point scale (L0-L5) with specific observable criteria per level
• [ ] Answer all 28 diagnostic questions with honest scoring
• [ ] Calculate dimension scores and overall readiness score
• [ ] Identify 3-5 weakest factors that need immediate attention
• [ ] Prioritize fixes: data first, then governance, then infrastructure
• [ ] Generate 6-month roadmap with milestones and owners
• [ ] Assess data quality across 12 dimensions specific to AI
• [ ] Check if data is centralized on a single platform (warehouse + lake)
• [ ] Verify data accessibility without extensive bureaucracy
• [ ] Confirm data governance with clear ownership and lineage tracking
• [ ] Ensure data access controls are in place for AI use cases
• [ ] Check role-based access with audit trails
• [ ] Verify sub-processor agreements are ready
• [ ] Assess infrastructure: cloud platform with GPU/inference capacity
• [ ] Check MLOps tooling and CI/CD pipelines for ML
• [ ] Verify integration APIs to systems of record (SAP, Salesforce, etc.)
• [ ] Assess network egress and model provider access
• [ ] Evaluate talent: data science, ML engineering, domain expertise
• [ ] Check for dedicated AI team vs. individual contributors
• [ ] Assess leadership AI literacy and commitment
• [ ] Verify AI-specific governance accountability (AI Risk Officer or Council)
• [ ] Check for risk framework covering AI systems
• [ ] Verify model oversight and monitoring processes
• [ ] Confirm audit readiness for AI systems
• [ ] Map compliance requirements (EU AI Act, GDPR, HIPAA, SOC 2)
• [ ] Tag each use case with EU AI Act risk classification
• [ ] Identify and prioritize candidate AI use cases
• [ ] Score each use case on Impact-Easy axis (1-9)
• [ ] Classify each as build, buy, or partner
• [ ] Estimate ROI for top use cases
• [ ] Create delivery roadmap with 6-month milestones
• [ ] Assess organizational culture readiness for AI-driven change
• [ ] Verify executive sponsorship with dedicated budget
• [ ] Identify AI champions in business units
• [ ] Check for openness to AI-driven workflow changes
• [ ] Calculate enterprise AI TCO for investment
• [ ] Plan AI adoption change management
• [ ] Establish AI governance ownership
• [ ] Map AI compliance checklist requirements
• [ ] Consider BYOK for cost control
• [ ] Apply zero-trust architecture to AI systems
• [ ] Apply OWASP LLM Top 10 security controls
• [ ] Set up platform monitoring for AI
• [ ] Plan AI incident response procedures
• [ ] Re-assess readiness quarterly as AI capabilities evolve
• [ ] Document assessment results and gap closure progress
• [ ] Present results to board with prioritized action plan
• [ ] Test: assessment scores align with actual pilot outcomes
• [ ] Document readiness assessment methodology and scoring criteria

FAQ

What is an AI readiness assessment?

An AI readiness assessment is a structured evaluation of an organization's ability to adopt AI productively, scoring data, infrastructure, talent, governance, use case viability, and culture to produce a prioritized action plan. AI Advisory Practice: "73% of enterprise AI failures trace back to readiness gaps that were knowable before the first dollar was spent. The six readiness dimensions: data maturity, infrastructure, talent, governance foundations, use case viability, and organizational culture readiness, each with a scored 5-point assessment scale and 20+ diagnostic questions." NextAgile: "Most enterprises do not start their AI journey with a readiness assessment. They start with a demo. Then things slow down. The model cannot access clean internal knowledge. Legal gets nervous. Teams disagree on ownership. The real issue is that the organization was never operationally ready for AI deployment." Knowlee: "The output is a decision artifact, not a status report."

What are the six dimensions of AI readiness?

The six dimensions of AI readiness are data, infrastructure, talent, governance, use case viability, and culture. AI Advisory Practice: (1) Data maturity — 12 data quality dimensions specific to AI, feature availability, data governance conditions. (2) Infrastructure — compute, MLOps tooling, integration APIs. (3) Talent — data science, engineering, domain expertise, leadership. (4) Governance — risk frameworks, model oversight, audit readiness. (5) Use case viability — impact vs. effort scoring, build/buy/partner classification. (6) Organizational culture — readiness for change, executive sponsorship. Flywheel: "Strengths in one area do not compensate for weaknesses in another — they compound. Each dimension is assessed independently." Cisco: "Being AI-ready is not about ambition or budget. It is about six critical pillars working together: Strategy, Infrastructure, Data, Governance, Talent, and Culture."

How do you score AI readiness?

Score AI readiness on a 5-point scale per dimension, with specific observable criteria for each level. AI Advisory Practice: "Each dimension includes a 5-point scale with specific observable criteria. Benchmark data across five industries shows typical readiness profiles at L1 through L4 maturity levels." Internative: "5 dimensions, 28 questions. Each dimension scores 0-12 (4 sub-questions x 0-3 each). Maximum total: 60. Anything under 40 is a serious gap that should be addressed before AI strategy execution begins." Scoring: Score 3 = fully ready, Score 2 = partially ready, Score 1 = minimal readiness, Score 0 = not ready. Flywheel: "Each dimension is scored on a 0-100 scale. The overall AI readiness score is the weighted average across all six dimensions. Equal weighting is the default; organizations may adjust weights based on strategic priorities."

What are the most common AI readiness gaps?

The most common AI readiness gaps are data quality, governance, and culture. AI Advisory Practice: "Most organizations systematically overestimate their data and governance readiness. The five most common gaps we observe in assessment work." NextAgile: "Some organizations score high technically but fail culturally. Others have executive enthusiasm but fragmented systems and unusable data. Occasionally, companies with strong engineering teams have no governance model at all. Those projects usually stall later, not earlier." Knowlee: "Most enterprise AI projects fail because one domain is silently low while the executive sponsor assumes all six are aligned." Flywheel: "Organizations with pristine architecture and skilled teams still fail on AI when their data is siloed, inconsistent, or inaccessible. AI readiness is fundamentally data readiness." Common gaps: (1) Data siloed across 5+ systems with manual joins. (2) No formal data governance or quality audits. (3) No AI-specific governance or risk officer. (4) Infrastructure on-prem only, no GPU capacity. (5) No documented workflows for AI to improve.

How do you close AI readiness gaps?

Close AI readiness gaps by prioritizing the weakest dimensions first, starting with data. Flywheel: "1. Data Readiness — Fix data quality and accessibility first. Nothing else works without it. 2. Delivery Process — Modernize CI/CD and testing. 3. Architecture — Move toward API-first and cloud-native patterns. This is the slowest dimension to improve, so start early. 4. Workforce — Launch upskilling programs. Skills improvements compound over time. 5. Governance — Establish policies and frameworks before scaling beyond pilots. 6. Leadership — Secure dedicated budget and executive sponsorship for long term." Knowlee: "The output is a 426-line strategic document that maps 43 candidate AI use cases, scores each on Impact-Easy axis (1 to 9), selects 15 Top-3 priorities, classifies each as build/buy/partner, and sequences them onto a 6-month roadmap." Internative: "Identifies the 3-5 weakest factors and tells you what to address before writing the strategy." Key: fix data first, then governance, then infrastructure, then talent — in parallel with use case identification.

Want a self-hosted AI company brain that does all of this out of the box?
Book a demo →