In most companies, the strategic plan is a sacred document. It's born from offsites and intense brainstorming sessions, meticulously crafted into a PowerPoint deck or a detailed spreadsheet. It represents the company's north star. But once the presentation is over, a fatal gap emerges. The plan is static, while the business is dynamic.
This document, meant to guide every action, quickly becomes a relic—a snapshot in time, disconnected from the daily operations, engineering sprints, and sales calls that define the business. Progress tracking is a manual, weekly chore of chasing down numbers and updating cells. The real-time pulse of the company is lost in translation.
What if we could change that? What if we treated our strategy not as a document, but as a living, breathing piece of software? This is the core principle behind STRATEGY AS SOFTWARE—a new paradigm where your business plans become actionable code, and your highest-level KPIs are exposed through a simple, powerful API.
The problem with traditional planning isn't the strategy itself; it's the medium. A slide deck can't tell you when a key result is falling behind. A spreadsheet can't automatically trigger a notification when a target is met. They are passive artifacts in an active environment.
This is where the concept of Business-as-Code comes in. By defining your strategy programmatically, you transform it from a static declaration into an executable program. Your company's objectives become a living service that can be queried, updated, and integrated into your entire tech stack.
With an API-first approach, your strategic plan becomes an active participant in your business automation, not just a bystander.
So, what does this look like in practice? Instead of building a spreadsheet, your leadership team or Head of Strategy can define a plan using a clean, intuitive API.
Imagine your goal is to scale customer acquisition in the next quarter. With Plans.do, you can codify this entire objective, complete with measurable key results.
Here’s an example using the Plans.do SDK in TypeScript:
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:
This isn't just data entry. You have just created a version-controlled, machine-readable strategic asset. This object, with its unique ID (plan_abc123xyz), is now the single source of truth for your Q3 marketing strategy.
Now that the strategy is code, we can connect it directly to the operational systems that drive the results. This is where the magic of the Strategic Planning API truly shines.
1. Automate Progress Tracking:
Your Generate 5,000 MQLs key result (kr_1) shouldn't be updated manually. You can set up a simple watcher that queries your CRM (e.g., Salesforce) or marketing automation platform (e.g., HubSpot) and updates the key result's value via an API call.
// Example of a daily sync job
const mqlCount = await getMQLsFromSalesforce();
await plans.keyResults.update('kr_1', { value: mqlCount });
The gap between execution and strategic visibility is now closed. Progress is tracked in real-time, without human intervention.
2. Cascade Goals into Tactical Work:
Your plan defines the why. Now you can automate the creation of the how. Use the Plans.do API to trigger workflows in your project management tools.
For instance, upon creating the Q3 2025 plan, you could programmatically:
This ensures that every piece of tactical work has a clear, direct lineage to a top-level company objective.
When your strategy is exposed as an API, you unlock the ultimate executive dashboard. You can build internal tools, Geckoboard dashboards, or even Slack bots that query the Plans.do API and display the up-to-the-minute status of every company objective.
The CEO no longer needs to ask for a status update. They can see a live, accurate view of performance against targets because the dashboard is powered by the same systems where the work is happening. It's a true "Dashboard as a Service," built on a foundation of Execution as Code.
Stop letting your strategy die in documents. It's time to turn your business plans into dynamic, automated workflows.
Why use an API for strategic planning?
An API-first approach transforms static plans into dynamic, executable programs. It allows you to integrate strategic objectives directly into your business applications, automate progress tracking, and trigger workflows based on milestones, ensuring your strategy is always synchronized with your operations.
How does Plans.do handle progress tracking?
Each key result in a Plan object can be updated via the API. You can connect operational systems (like CRMs, analytics platforms) to automatically push updates, providing real-time visibility into performance without manual reporting and bridging the gap between strategy and execution.
Can I integrate Plans.do with tools like Jira or Asana?
Yes. Plans.do is designed for composition. Use our API to set the high-level strategic direction (the 'why') and then create corresponding tasks or epics in project management tools (the 'how'), linking tactical execution directly back to strategic goals.
What does 'Business-as-Code' mean for planning?
It means treating your strategic plan not as a document, but as a version-controlled, testable, and executable piece of software. Your company's strategy becomes a living service that can be queried, updated, and integrated into your entire tech stack, making it an active participant in your business automation.