In the world of software development, Git is the undisputed king of collaboration and version control. We use it to track every change, review new features through pull requests, and maintain a clear, auditable history of our codebase. So why do we let our company's most important code—its strategy—live in static spreadsheets, siloed documents, or clunky web UIs?
Traditional OKR (Objectives and Key Results) management is often disconnected from the daily workflows where work actually happens. It involves manual updates, lacks transparent history, and makes it difficult to understand why a strategic pivot was made months ago. It’s like trying to build a complex application without source control.
What if you could apply the same battle-tested principles of Git to your company's objectives? This is the core idea behind Strategy-as-Code, a paradigm that transforms your goals into version-controlled, auditable, and automated artifacts. With a platform like Goals.do, this isn't just a theory—it's a practical workflow.
Before we dive into the solution, let's acknowledge the friction in most goal-setting processes:
The "as-Code" movement (Infrastructure-as-Code, Policy-as-Code) is about defining systems in a declarative, readable, and version-controlled format. Goals-as-Code applies this same logic to your strategic objectives.
Instead of clicking through a UI, you define your company's OKRs in a simple text file (like YAML or JSON) and store it in a Git repository. This repository becomes the single source of truth for your company's direction.
Here’s why this is a game-changer when combined with a platform like Goals.do:
This all sounds great in theory, but how does it work in practice? Goals.do acts as the execution engine that turns your version-controlled definitions into live, tracked objectives.
Here’s a step-by-step workflow.
Create a file in your repository, for example, okrs/q4-2024.yml. Define your objectives in a clean, human-readable format.
# okrs/q4-2024.yml
- objectiveId: 'eng-q4-product-launch'
title: 'Launch V2 of Flagship Product'
owner: 'product-team@example.com'
timeframe: 'Q4 2024'
keyResults:
- description: 'Achieve 10,000 active users'
target: 10000
- description: 'Secure 5 major media placements'
target: 5
- description: 'Maintain an app store rating of 4.8+'
target: 4.8
Commit your file and open a PR.
git checkout -b feat/q4-company-okrs
git add okrs/q4-2024.yml
git commit -m "feat: Propose company objectives for Q4 2024"
git push origin feat/q4-company-okrs
Now, your leadership and team leads can review the proposed goals, suggest changes, and have a rich discussion directly within the pull request. It’s a transparent and asynchronous review process built for modern teams.
Once the PR is approved and merged into main, automation takes over. Using a CI/CD pipeline (like GitHub Actions), a script runs automatically. This script reads your YAML file and uses the Goals.do SDK to create or update the objectives in the platform.
Here's what that automation script might look like using the goals.do SDK:
// .github/workflows/sync-okrs.ts
import { Goals } from 'goals.do';
import { readFileSync } from 'fs';
import { parse } from 'yaml';
// 1. Read the definition file from the repo
const file = readFileSync('okrs/q4-2024.yml', 'utf8');
const objectives = parse(file);
// 2. Loop through and sync with Goals.do
for (const objective of objectives) {
// Use the API to create or update the objective
await Goals.create({
title: objective.title,
owner: objective.owner,
timeframe: objective.timeframe,
keyResults: objective.keyResults.map(kr => ({
description: kr.description,
target: kr.target,
current: 0 // Progress is updated from other systems
}))
});
}
console.log('✅ Q4 2024 OKRs successfully synced with Goals.do!');
Your Git repository defines the goal, but Goals.do tracks the progress. The platform provides a simple API to update the current value of your key results.
Instead of manual updates, you connect your systems directly:
Your OKRs are no longer static targets in a document; they are living, breathing metrics that reflect the real-time state of your business.
By treating your strategy like a software project, you bring a new level of rigor, transparency, and automation to your business. You replace disconnected tools and manual processes with a developer-first workflow that integrates directly into the systems you already use.
This is more than just a new way to track goals—it's a fundamental shift in how you plan and execute your company's vision.
Ready to start managing your OKRs as code? Explore Goals.do and turn your company's strategic objectives into executable workflows.