At Goals.do, we believe in a simple but powerful principle: if a product is truly valuable, its creators should be its most avid users. This practice, affectionately known in the tech world as "dogfooding," isn't just a marketing gimmick for us. It's the core of our development process and the engine that drives our own business strategy.
Our mission is to transform OKR and goal management from a static, manual chore into a dynamic, automated part of your operational fabric. We built a developer-first platform to manage goals as code because we were tired of the alternative: spreadsheets that go stale, disconnected dashboards, and quarterly objectives that are forgotten by week two.
So, how do we use our own API-driven goal platform to run Goals.do? Let’s pull back the curtain.
Traditional OKR software creates a new destination, another tab to open, another UI to learn. This immediately separates your company's strategy from its execution. The result is a familiar cycle:
We built Goals.do to break this cycle. Our strategy shouldn't live in a silo; it should be integrated directly where the work happens.
For us, every company objective and key result (OKR) begins its life in a dedicated Git repository. Treating our goals as code gives us several immediate advantages:
Here’s a simplified example of how our Q4 Product Objective is defined in our strategy repository:
import { Goals } from 'goals.do';
// This file is part of our main strategy definition
// Merging this to main automatically creates the objective via a CI job
Goals.create({
title: 'Launch V2 of Flagship Product',
owner: 'product-team@goals.do',
timeframe: 'Q4 2024',
tags: ['product', 'major-release', 'q4'],
keyResults: [
{
id: 'kr_active_users',
description: 'Achieve 10,000 active users',
target: 10000,
current: 0 // This will be updated automatically
},
{
id: 'kr_media_placements',
description: 'Secure 5 major media placements',
target: 5,
current: 0 // Updated via a manual API call from marketing
},
{
id: 'kr_api_uptime',
description: 'Maintain API uptime of 99.95%',
target: 99.95,
current: 100 // Updated continuously from our monitoring service
}
]
});
Once this is merged, the goal is live in our system. But defining it is just the start. The real power comes from automating the progress updates.
This is the magic of an API-driven goal management system. We connect our key results directly to the business systems that generate the data. This eliminates manual updates and ensures our goals always reflect ground truth, in real-time.
Here are three real-world examples of how we automate our own KRs:
# A simplified script run by our CI job
UPTIME=$(get_datadog_uptime_slo)
curl -X PATCH "https://api.goals.do/v1/keyresults/kr_api_uptime" \
-H "Authorization: Bearer $GOALS_DO_API_KEY" \
-d '{ "current": '$UPTIME' }'
Result: Our platform reliability goal is never out of date. We don't need a person to check a dashboard and copy-paste a number.
// A serverless function triggered on new user creation
import { Goals } from 'goals.do';
export async function handler(event) {
// Logic to confirm new user event
await Goals.keyResults.increment('kr_new_signups', { by: 1 });
return { statusCode: 200 };
}
Result: Our growth goal ticks up with every single sign-up, giving us a real-time pulse on our marketing and product efforts.
Result: Our revenue goals are tied directly to our payment processor. There is zero ambiguity and zero chance for human error in reporting.
"If it's all in code and APIs, how does the team see progress?"
This is a crucial question. The answer is that we bring the goal data to the tools our team already uses. Instead of forcing them to a new platform, we pipe the information to them.
By treating our goal data as just another data source, we can integrate it anywhere, turning our company strategy into an ambient, ever-present part of our work environment.
Running Goals.do on Goals.do has fundamentally changed how we operate.
If you're ready to stop chasing manual updates and start integrating your strategy directly into your execution, it's time to rethink your approach. See how Business-as-Code can transform your OKR management.