In the fast-paced world of modern business, strategic plans are often relics before the ink is even dry. We've all been there: a beautifully crafted slide deck or a detailed spreadsheet outlines ambitious quarterly Objectives and Key Results (OKRs), only to be filed away and forgotten. The strategy sits in a silo, disconnected from the daily operations and engineering work that's meant to drive it.
What if we treated our business strategy not as a static document, but as a living, executable piece of software?
This is the core principle behind Business-as-Code. It’s the idea that your company's most critical plans should be as dynamic, version-controlled, and integrated as your application code. At Plans.do, we've built the platform to make this a reality.
This guide will walk you through how to use the Plans.do Strategic Planning API to transform your OKRs from passive goals into an active, automated part of your operational toolkit.
The fundamental challenge with traditional planning is the gap between the "why" and the "how."
This disconnect leads to manual reporting, misaligned teams, and a strategy that fails to adapt to real-time business realities. Progress tracking becomes a quarterly fire drill of chasing down data instead of a continuous, automated process.
Plans.do bridges this divide by providing a simple but powerful OKR API. Instead of a document, your plan becomes a structured object that your systems can read, update, and react to. This is Execution as Code—making your strategy an active participant in your business automation.
Let's see how it works.
Forget convoluted spreadsheets. With Plans.do, you can define your entire quarterly plan in a few lines of clear, declarative code. Here’s how you would create a new strategic plan for Q3 focused on scaling customer acquisition.
import { plans } from 'do-sdk';
const newPlan = await plans.create({
name: 'Q3 2025: Scale Customer Acquisition',
owner: 'marketing@example.com',
timeframe: {
start: '2025-07-01',
end: '2025-09-30'
},
objectives: [
{
objective: 'Increase qualified leads by 20%',
keyResults: [
{ id: 'kr_1', name: 'Generate 5,000 MQLs', value: 0, target: 5000 },
{ id: 'kr_2', name: 'Achieve 15% MQL to SQL conversion', value: 0, target: 0.15 }
]
},
{
objective: 'Reduce Customer Acquisition Cost (CAC) by 10%',
keyResults: [
{ id: 'kr_3', name: 'Decrease cost-per-click to $2.50', value: 3.10, target: 2.50 },
{ id: 'kr_4', name: 'Improve landing page conversion to 5%', value: 0.03, target: 0.05 }
]
}
]
});
console.log(newPlan.id);
// plan_abc123xyz
Let's break this down:
You've just codified your strategy. It now has an ID (plan_abc123xyz) and exists as a structured object, ready to be integrated into your workflows.
A plan's "create" call is just the beginning. The real power of Strategy Automation comes from updating your plan as work happens. Because your OKRs are accessible via an API, you can connect them directly to your operational systems.
Imagine your CRM logs a new "Marketing Qualified Lead" (MQL). You can set up a simple service that automatically updates the relevant Key Result in Plans.do.
// A function in your backend service that runs when a new MQL is generated
async function onNewMqlGenerated() {
const planId = 'plan_abc123xyz';
const keyResultId = 'kr_1'; // 'Generate 5,000 MQLs'
// Increment the key result's value by 1
await plans.keyResults.increment(planId, { id: keyResultId });
}
Or, let's say a nightly job calculates your landing page conversion rate. You can push that new value directly to the plan.
// A nightly cron job
async function updateLandingPageConversion() {
const newConversionRate = await analytics.getLandingPageConversion(); // Fetches 0.035
await plans.keyResults.update('plan_abc123xyz', {
id: 'kr_4', // 'Improve landing page conversion to 5%'
value: newConversionRate
});
}
With this approach, your strategic plan is always synchronized with reality. There's no manual data entry, no stale reports. Your dashboards, alerts, and reviews can all pull directly from Plans.do as the single source of truth for strategic progress.
Plans.do is designed for composition. It excels at defining the high-level strategy (the "why") and is meant to connect with project management tools like Jira or Asana, which handle tactical execution (the "how").
This creates a powerful, traceable workflow:
This closes the loop between code commits and company objectives, giving every task a clear strategic purpose.
Adopting a Business-as-Code mindset means moving your strategy from a fragile document to a robust, integrated service. By using the Plans.do API, you gain:
Your company's strategy deserves to be a first-class citizen in your tech stack. Stop archiving your plans and start executing them.
Ready to turn your strategy into software? Explore the Plans.do documentation and get your API key today.