IT Governance Frameworks Compared

IT Governance Frameworks Compared: COBIT vs. ITIL vs. TOGAF

A bank adopted all three. The governance office mapped its controls to COBIT. Operations ran change enablement and configuration management on ITIL. The architecture team published baseline and target architectures in TOGAF. When auditors asked a single question, which applications process customer financial data and what do they depend on, three teams produced three answers: a control register listing 214 applications, a configuration database listing 301, and an architecture repository listing 187. Every framework was being followed faithfully. None of the three could say which list was right.

The frameworks themselves are easy to tell apart. COBIT asks what should be governed and who is accountable. ITIL asks how services are delivered, changed, and supported day to day. TOGAF asks how the architecture is designed and how it evolves from the current state to a target. Most comparisons stop there, with a table of scope, size, and certification paths, and a recommendation to combine them. That is useful, and it leaves out the question the bank could not answer.

All three frameworks consume the same input: an accurate account of which applications exist, what they do, what data they handle, and what depends on them. None of the three produces it. In estates built on COBOL, shared databases, and batch chains, that account lives in code rather than in any register. The comparison below sets out what each framework is, how they differ, how they layer, and what each demands from the portfolio, then uses that comparison to show where legacy estates break all three at the same point.

Impact Checks Inside the CAB Meeting

SMART TS XL gives configuration, risk, and architecture teams one code-derived inventory, so the numbers finally agree.

FIND OUT MORE…

The Short Answer: Govern, Manage, Design

The shortest accurate summary is that COBIT governs, ITIL manages, and TOGAF designs. COBIT sits closest to the board and the audit committee, setting the objectives that technology must serve and the accountabilities for achieving them. ITIL sits closest to operations, defining the practices that keep services running and changing safely. TOGAF sits between them, translating strategy into an architecture and a plan for getting there. None of the three replaces the others, and treating them as competitors is the most common mistake organizations make when choosing between them. The table sets them side by side on the dimensions that matter most for selection.

DimensionCOBITITIL 4TOGAF
StewardISACAPeopleCert (Axelos)The Open Group
Core questionWhat should we govern, and who is accountable?How do we deliver and change services reliably?How do we design and evolve the architecture?
Primary lensGovernance and management of enterprise ITService managementEnterprise architecture
StructureGovernance and management objectives grouped into five domainsService value system, value chain, and practicesArchitecture Development Method, repository, and content framework
Typical outputsControl mappings, capability assessments, accountability chartsProcess definitions, service levels, change and incident recordsBaseline and target architectures, gap analysis, migration plans
Primary audienceBoards, risk, audit, CIOsService owners, operations, supportEnterprise architects, CIOs, programme leads
StrengthAuditable, risk-aware, tied to enterprise goalsOperational consistency and service accountabilityStructured target-state design and stakeholder alignment
Blind spotDoes not tell you how to build or verify the inventory it assumesSteady-state focus; migrations are outside its coreGoverns architecture compliance, not enterprise IT as a whole

Each Framework in Brief

Each framework has a distinct centre of gravity, and understanding it explains both its strengths and its limits. COBIT is organized around governance and management objectives and is explicit about accountability. ITIL is organized around the flow of value through services and is explicit about operational practice. TOGAF is organized around a method for producing and maintaining architecture and is explicit about stakeholders and transitions. The three also differ in how they are adopted. COBIT is typically tailored through design factors, ITIL is adopted practice by practice, and TOGAF is applied through its method and then adapted. The sections below summarize each in turn, with the part of it that depends most on accurate portfolio data.

COBIT

Purpose. COBIT is ISACA’s framework for the governance and management of enterprise information and technology. COBIT 2019 organizes forty governance and management objectives into five domains: Evaluate, Direct and Monitor; Align, Plan and Organize; Build, Acquire and Implement; Deliver, Service and Support; and Monitor, Evaluate and Assess. Design factors help an organization tailor the system to its goals, risk appetite, and operating model, and capability levels measure how well each objective is performed.

Strength. It connects technology to enterprise goals and to risk, and it produces evidence an auditor can follow, which is why it is favored in regulated industries and for board reporting.

Where it needs portfolio data. Objectives for managed assets, managed configuration, managed IT changes, managed risk, and managed compliance with external requirements all assume that the organization knows what it has and what it touches.

ITIL 4

Purpose. ITIL 4 describes a service value system and a value chain of activities (plan, improve, engage, design and transition, obtain and build, deliver and support), supported by 34 management practices. It is the most widely adopted of the three, and its practices, such as incident management, problem management, change enablement, release management, and service configuration management, define how operations work.

Strength. It gives operational teams a shared vocabulary and consistent processes, with clear accountability for service levels.

Where it needs portfolio data. Change enablement needs to assess the impact of a change before it is approved. Service configuration management needs configuration items and their relationships. Problem management needs a way to trace a failure to its cause. Each of these is only as good as the dependency data behind it.

TOGAF

Purpose. TOGAF, from The Open Group, centres on the Architecture Development Method, a cycle that moves from architecture vision through business, information systems, and technology architectures to opportunities, migration planning, implementation governance, and architecture change management. It works from a baseline architecture toward a target and identifies the gaps between them.

Strength. It gives modernization and integration programs a structured way to define a target state and align stakeholders around it.

Where it needs portfolio data. The baseline is the starting point of the whole method. Gap analysis and migration planning require knowing the current applications, data, and dependencies accurately enough to sequence the work.

Where They Overlap and Where They Collide

The three frameworks overlap on change, risk, and architecture, and they collide on one thing in particular: each keeps its own record of what the estate contains. COBIT’s asset and configuration objectives, ITIL’s configuration management and asset management practices, and TOGAF’s baseline application architecture all describe the same applications. They are typically owned by different teams, built at different times, from different sources, and maintained to different standards. The table shows how the same question is answered in each.

QuestionCOBITITIL 4TOGAF
Which applications exist?Managed assets and configuration objectives expect an accurate inventoryService configuration management and IT asset management practicesBaseline application architecture in the ADM
What depends on what?Relationships support risk and change objectivesRelationships feed change impact assessmentDependencies drive gap analysis and migration planning
What changed?Managed IT changes objectiveChange enablement and release managementArchitecture change management phase
Is it compliant?Managed compliance with external requirementsControls and practices evidenced through operationsImplementation governance and compliance reviews
Who is accountable?Accountability charts per objectivePractice and service ownersArchitecture board and governance framework

Three registers of the same estate are not a governance strategy. They are three opportunities for the numbers to disagree, as they did for the bank in the opening.

How the Frameworks Layer in Practice

Organizations that use more than one framework usually arrange them in layers: COBIT for direction and accountability, TOGAF for target state and transition, and ITIL for day-to-day delivery and change. The layering works because each answers a different question at a different altitude. It works only if the layers share a foundation. The diagram adds that foundation explicitly.

Direction and accountability     COBIT      objectives, risk appetite, assurance
              |
Target state and transition      TOGAF      baseline, target, gaps, migration plan
              |
Day-to-day delivery and change   ITIL 4     incidents, changes, configuration, releases
              |
Shared input to all three        One evidence baseline: applications, dependencies, data

The bottom layer is the one most programs omit. Without it, each framework builds its own picture, and the layering produces three confident answers instead of one.

Choosing Between Them

The right starting point depends on the problem the organization is trying to solve, not on the framework’s reputation. The table maps common problems to a sensible first move. Sequencing matters more than selection: adopting all three at once rarely succeeds, and the evidence baseline should come first because every framework depends on it. One comparison guide puts typical implementation effort at roughly 6 to 12 months for COBIT, 3 to 9 months for ITIL, and 9 to 18 months for TOGAF, though estimates vary widely with scope and should be treated as orders of magnitude.

If your main problem isStart withWhy
Audit findings, regulatory accountability, board reportingCOBITGives governance structure and evidence an auditor can follow
Unstable services, repeated incidents, failed changesITIL 4Standardizes the operational practices that cause the instability
Modernization or integration with an unclear target stateTOGAFDefines baseline, target, gaps, and a migration path
Post-merger integrationTOGAF baseline, then COBIT governanceEstablishes the combined estate before accountability is assigned
Regulated enterprise running both legacy and modern estatesCOBIT overlay on ITIL operations, with a TOGAF baselineGovernance on top, operations beneath, shared baseline under both

The Evidence Problem: What Each Framework Needs From Your Portfolio

Every framework has artifacts that depend on portfolio facts. In modern, well-instrumented estates those facts come from discovery tools, tags, and service maps. In estates built on COBOL, JCL, shared datasets, and batch dependencies, they do not exist in any register, because the relationships live in code: which programs include which copybooks, which jobs run which programs, which datasets flow between them. The table lists the framework artifacts that depend on those facts and the failure that follows when the facts are missing.

Framework artifactWhat it requiresTypical failure in legacy estates
COBIT managed configuration and managed assetsAccurate configuration items and relationshipsConfiguration database lacks programs, copybooks, jobs, and datasets
COBIT managed riskInventory and dependencies to build risk scenariosUnknown dependencies make risk ratings guesses
COBIT compliance with external requirementsWhere regulated data is processedRegulated fields never located in record layouts
ITIL change enablementImpact assessment before approvalNo impact data across batch and shared-data dependencies
ITIL service configuration managementComplete configuration recordsRecords built by hand, stale within months
ITIL problem managementA way to trace failures to causesInvestigation starts from memory, not from the code
TOGAF baseline architectureCurrent applications, data, and technologyBaseline built from interviews and diagrams that predate the code
TOGAF gap analysis and migration planningDependencies to sequence the workRetirements blocked by consumers nobody listed
TOGAF implementation governanceA way to verify projects conform to the architectureNo structural check, only document review

One record can serve all three frameworks if it is derived from the code instead of assembled by hand. The annotated example shows a single application record and which framework consumes each part of it.

yaml

application: BILLRUN
  # COBIT managed configuration, ITIL service configuration: items and relationships
  components: {programs: 118, copybooks: 31, jobs: 12, datasets: 24}
  relationships:
    inbound_dependents: 41
    outbound_dependencies: 12
  # COBIT managed risk and compliance
  data_classes: [financial, pii]
  regulatory_functions: [quarterly_capital_report]
  # ITIL change enablement: input to impact assessment
  change_impact_scope: derived_from_dependency_graph
  # TOGAF baseline and gap analysis
  baseline_status: derived          # assumed | derived | verified
  technical_health: {avg_cyclomatic_complexity: 24, dead_code_pct: 31}

Governing a Modernization: Where Each Framework Runs Out

Modernization exposes a limit shared by all three frameworks. A recent practitioner framework paper makes the case that existing frameworks leave a gap around actively executing migrations: ITIL provides strong steady-state change and incident practice but does not say how a migration in flight should be governed, COBIT defines what governance should achieve and who is accountable but not what governed execution looks like, and TOGAF defines target-state architecture but offers little on controlling the transition. The gaps cluster around the same things: mapping legacy dependencies before decommissioning, keeping architecture decisions auditable across months of migration, and validating data quality across a platform transition.

The checkpoints below show how the frameworks can be combined to close that gap, with the evidence each checkpoint requires.

Modernization checkpointFramework homeEvidence required
Wave scope is dependency-closedTOGAF migration planning, COBIT change transition objectiveVerified dependency graph for the wave
Each change is impact-assessedITIL change enablementImpact scope derived from code, not estimated
Regulated data and functions are accounted forCOBIT compliance objectiveLocated regulated fields and the programs that process them
Architecture decisions are traceableTOGAF architecture governanceDecisions linked to the structural evidence behind them
Decommissioning is verifiedCOBIT asset lifecycle, ITIL retirement practiceZero inbound dependencies confirmed; retirement certificate

Frequently Asked Questions

Which is better, COBIT, ITIL, or TOGAF? They answer different questions, so none is better in general. COBIT suits governance and audit, ITIL suits service operations, and TOGAF suits architecture and transition planning. Most large organizations use more than one.

Can you use all three together? Yes, usually in layers: COBIT for governance, TOGAF for architecture, ITIL for operations. Adopt them in sequence, starting with whichever addresses the most pressing problem, and give them a shared baseline of applications and dependencies.

Is TOGAF a governance framework? It includes architecture governance, covering compliance of projects with the architecture, but it is not an enterprise IT governance framework in the way COBIT is. Its governance concerns architectural decisions and conformance.

Is ITIL governance or management? ITIL is a management framework. It defines how services are planned, delivered, and improved, and it is commonly run beneath a governance layer such as COBIT.

Do these frameworks help with legacy modernization? They provide structure, and each assumes an accurate inventory and dependency picture. For legacy estates, that picture usually has to be derived from code before the frameworks can do their work.

How SMART TS XL, ASK AI, and the MCP Connector Feed All Three Frameworks

SMART TS XL supplies the evidence baseline that the three frameworks share, and its ASK AI and MCP Connector capabilities decide how many people across governance, architecture, and operations can use it.

Enterprise search across languages builds the inventory from source libraries, load libraries, and job schedules, which is what COBIT’s configuration objectives, ITIL’s configuration records, and TOGAF’s baseline all need and what hand-built registers miss. Application dependency mapping supplies the relationships: callers, shared copybooks, dataset flows, and downstream consumers, refreshed as the estate changes. Structural impact analysis turns that graph into the impact scope that ITIL change enablement and COBIT change objectives call for before a change is approved. Static code analysis measures complexity, coupling, and security patterns, which gives the risk and technical health inputs for governance reporting and architecture decisions. Legacy modernization analysis identifies dead and unreachable code, which removes programs from migration scope and anchors verified retirement.

ASK AI over verified context lets auditors, architects, and service managers ask for evidence in plain language against a scoped result set. A request such as mapping every job and program that touches a given table, or extracting every validation rule from a payment cycle, produces an answer whose findings stay linked to the source lines they came from, which is the kind of traceability an audit trail relies on. Saved and shared prompts turn recurring audit requests into repeatable queries. The SMART TS XL MCP Connector makes the same answers available inside approved assistants such as ChatGPT, Claude, Copilot, Gemini, and Grok, so a change manager in a review board meeting can ask which programs a proposed change touches without leaving the tool they are already using. Access is read-only, authenticated, and role-based.

Framework needEvidenceCapability
COBIT and ITIL configuration recordsPrograms, jobs, datasets, and relationshipsEnterprise search and application dependency mapping
ITIL and COBIT change impact assessmentImpact scope of a proposed changeStructural impact analysis
COBIT risk and complianceTechnical health, security patterns, regulated data locationsStatic code analysis and ASK AI
TOGAF baseline and gap analysisCurrent-state applications, data, and dependenciesEnterprise search and application dependency mapping
TOGAF migration planningDependency-closed wave scope and dead codeImpact analysis and legacy modernization analysis
Audit and review questionsSource-linked answers in plain languageASK AI and the MCP Connector

Three boundaries keep expectations accurate. SMART TS XL is not a GRC platform, a CMDB, or an enterprise architecture repository. It supplies evidence to those systems and does not replace them. It does not define policies, processes, or control objectives, and it does not certify an organization against any framework. And it does not hold cost, contract, or service level data. The frameworks still require the organizational work of assigning accountability and running the processes. What the evidence baseline removes is the argument about whose list is correct.

Pick Any Framework. Feed It the Same Facts.

The bank in the opening did nothing wrong in adopting three frameworks. Each team did its job well, with the artifacts its framework prescribes. The failure was a missing foundation: no single, evidence-based account of the estate that all three could draw on, so each built its own and each was plausible.

Choose the framework by the problem in front of you. Govern with COBIT when accountability and audit are the issue, manage with ITIL when service stability is the issue, design with TOGAF when the target state is the issue. Then derive the baseline from the code once, and let all three read from it. Three frameworks that agree about the facts will govern better than any one framework applied to three disagreeing lists.