In modern software development, A/B testing is second nature. We wouldn't dream of launching a major feature without testing button colors, user flows, or headline copy. We rely on data, not guesswork, to optimize user experience. But what about the bigger picture? What about the foundational strategies that drive our business?
Too often, strategic planning happens in a boardroom, based on historical trends, gut feelings, and expert opinions. We commit an entire quarter's worth of resources to a single plan, hoping it's the right one. But what if it isn't? What if we could apply the same rigorous, data-driven principles of A/B testing to our most critical business initiatives?
This is where "Business Planning as Code" changes the game. By using the Plans.do API, you can move beyond monolithic, high-stakes strategic bets and start running controlled experiments to discover the most effective path forward.
Traditional strategic planning is inherently risky. A team might spend weeks debating whether to focus on a direct sales model versus a channel partner model for a new market. They eventually pick one, create a 50-slide deck, and commit millions in budget and thousands of person-hours.
If they chose correctly, fantastic. But if their core assumption was wrong, the cost is enormous—not just in wasted resources, but in lost time and market opportunity. There has to be a better way to validate these high-level assumptions before going all-in.
The core philosophy of Plans.do is that your strategy should be as versionable, testable, and automated as your software. By defining your business plans in code, you unlock powerful capabilities:
These principles create the perfect environment for running strategic A/B tests.
Let's walk through a practical example. Imagine your company wants to expand into the APAC region. The leadership team is divided on the best go-to-market strategy.
Hypothesis: We believe a partner-led sales strategy will acquire new enterprise customers more efficiently than a direct sales approach over the next six months.
Instead of choosing one path, we'll define both as separate, measurable plans using the Plans.do API. Each plan will have the same high-level Objective but different Key Results that reflect the unique tactics of that strategy.
Here’s how you could model this:
import { plans } from '@do/sdk';
// Plan A: Direct Sales approach
const directSalesPlan = await plans.create({
name: "[Test A] APAC Expansion - Direct Sales",
description: "Validate direct sales model for acquiring 20 new enterprise logos in APAC.",
type: "OKR",
goals: [
{
objective: "Acquire 20 new enterprise customers in APAC",
keyResults: [
{ metric: "Enterprise Demos Completed", startValue: 0, targetValue: 100 },
{ metric: "Contracts Sent", startValue: 0, targetValue: 40 },
{ metric: "New Enterprise Logos Closed", startValue: 0, targetValue: 20 }
]
}
]
});
// Plan B: Partner-Led approach
const partnerLedPlan = await plans.create({
name: "[Test B] APAC Expansion - Partner-Led",
description: "Validate partner-led model for acquiring 20 new enterprise logos in APAC.",
type: "OKR",
goals: [
{
objective: "Acquire 20 new enterprise customers in APAC",
keyResults: [
{ metric: "New Channel Partners Signed", startValue: 0, targetValue: 10 },
{ metric: "Partner-Sourced Qualified Leads", startValue: 0, targetValue: 80 },
{ metric: "Partner-Sourced Logos Closed", startValue: 0, targetValue: 20 }
]
}
]
});
console.log("Plan A ID:", directSalesPlan.id);
// pln_a1b2c3d4e5f6g7h8
console.log("Plan B ID:", partnerLedPlan.id);
// pln_i9j8k7l6m5n4o3p2
We now have two distinct, trackable strategic experiments live in our system.
This is where the power of a planning API shines. You can now wire these plans directly into the tools your teams already use.
By automating data collection, you ensure an objective and real-time view of how each strategy is performing without relying on manual spreadsheets and weekly check-in meetings.
At the end of your designated test period (e.g., one quarter), you can programmatically fetch the state of both plans.
import { plans } from '@do/sdk';
const planA_id = 'pln_a1b2c3d4e5f6g7h8';
const planB_id = 'pln_i9j8k7l6m5n4o3p2';
const [planA_results, planB_results] = await Promise.all([
plans.get(planA_id),
plans.get(planB_id)
]);
// A simple function to calculate overall progress
function calculateProgress(plan) {
const kr = plan.goals[0].keyResults.find(kr => kr.metric.includes("Closed"));
return (kr.currentValue / kr.targetValue) * 100;
}
console.log(`Plan A Progress: ${calculateProgress(planA_results).toFixed(2)}%`);
console.log(`Plan B Progress: ${calculateProgress(planB_results).toFixed(2)}%`);
// Now you can compare leading indicators, costs, and final outcomes
// to determine the winning strategy.
The results are no longer a matter of opinion. You have clear data on which strategy was more effective at achieving the primary objective. You can now confidently double down on the winning approach with the full backing of your company's resources.
Why stop at two options? The beauty of a planning API is its scalability. You could easily design and launch Plan C (a product-led growth model) and Plan D (a market-specific advertising campaign) to run alongside the first two. This allows you to test multiple hypotheses simultaneously, dramatically accelerating your company's learning and adaptation cycle.
The era of betting the farm on a single, untested strategy is over. By treating your business plans as code, you can bring the discipline and data-driven rigor of software engineering to your company's most important decisions.
Plans.do provides the agentic workflow platform to define, track, and execute these strategic experiments. Stop debating and start testing.
Ready to run your first strategic experiment? Explore the Plans.do API documentation and turn your strategy into executable code today.