Connect Your Strategy: Integrating Plans.do with Jira, Asana, and Your CRM

Your company's strategy is ambitious. You've meticulously defined your Objectives and Key Results (OKRs), and your teams are hard at work. But a critical question lingers: is the work being done actually moving the needle on those high-level goals?

Too often, strategy lives in one world (slide decks, spreadsheets) while execution lives in another (Jira, Asana, Salesforce). This disconnect is the infamous "strategy-execution gap"—a void where manual reporting, misalignments, and missed opportunities thrive.

Plans.do isn't here to replace your favorite tools. It's designed to be the connective tissue that bridges this gap. By treating your strategy as executable code, you can build a powerful, automated system that links your highest-level goals directly to the operational tools your teams use every day.

From Static Document to Active Service: The "Business-as-Code" Shift

Before we dive into specific integrations, it's crucial to understand the philosophy behind Plans.do: Business-as-Code.

Instead of a static document, your strategic plan becomes a version-controlled, queryable, and executable piece of software, accessible via a Strategic Planning API. This means your company's goals are no longer a passive reference point. They become a living service that can:

Trigger workflows in other systems.
Receive real-time progress updates automatically.
Ensure that tactical work is always traceable back to a strategic "why."

This is the foundation of true Strategy Automation. Now, let's see how it works in practice.

Connecting the "Why" to the "How": Plans.do + Jira & Asana

Your project management tools are masters of the "how"—the tasks, stories, and epics that constitute your team's daily work. Plans.do provides the "why"—the overarching strategic objective that this work should serve. Integrating them creates a powerful, top-down flow of context.

Imagine your Q3 plan includes a major objective:

import { plans } from 'do-sdk';

const newPlan = await plans.create({
  name: 'Q3 2025: Scale Customer Acquisition',
  objectives: [
    {
      objective: 'Increase qualified leads by 20%',
      // ... key results
    }
  ]
});

Instead of manually creating a corresponding epic in Jira, you can automate it. Using the Plans.do API, you can build a simple integration that listens for new objectives and programmatically creates the necessary work items.

Conceptual Integration Flow (with Jira):

Define Strategy: An objective is created in Plans.do via the API.
Trigger Action: A webhook or a scheduled script detects the new objective.
Create Work: The script calls the Jira API to create a new Epic. The epic's description can be automatically populated with the objective details and a link back to the plan, ensuring full traceability.

// Pseudocode for an integration script
import { jiraApi } from './your-jira-connector';
import { plans } from 'do-sdk';

// This function could be triggered by a webhook from Plans.do
async function onNewObjective(objectiveData) {

  const epic = await jiraApi.createEpic({
    name: `Epic for: ${objectiveData.objective}`,
    description: `This epic directly supports the strategic objective: "${objectiveData.objective}".\n\nTrack overall progress here: https://app.plans.do/plan/${objectiveData.planId}`
  });

  console.log(`Created Jira Epic ${epic.key} for objective ${objectiveData.id}`);
}

// Example: Listen for new objectives and create epics
// (In a real app, this would be part of a server or webhook listener)

By connecting your plan to your project management, you ensure that every piece of work begins with a clear strategic purpose. This is Execution as Code in action.

Automating the "What Happened": Plans.do + CRMs & Analytics

The other side of the coin is automating progress tracking. Manually updating OKR spreadsheets is a soul-crushing, error-prone task. Your operational systems—your CRM, your analytics platform, your databases—already hold the ground truth. It's time to let them report for themselves.

This is where the Plans.do OKR API shines. You can create a bottom-up flow of data, turning your strategy into a self-updating, real-time dashboard.

Let's look at one of our Key Results from the Q3 plan:

{ id: 'kr_1', name: 'Generate 5,000 MQLs', value: 0, target: 5000 }

Instead of asking a marketing ops person to pull numbers from Salesforce or HubSpot every week, you can write a simple, scheduled script.

Conceptual Integration Flow (with a CRM):

Schedule a Job: A serverless function or cron job runs on a daily or weekly schedule.
Query the Source of Truth: The script calls your CRM's API to get the current count of new Marketing Qualified Leads for the quarter.
Update the Key Result: The script then calls the Plans.do API to update the value of the corresponding key result.

// Conceptual example for a scheduled sync job
import { keyResults } from 'do-sdk';
import { crmApi } from './my-crm-connector';

async function syncMQLsFromCRM() {
  // 1. Get real-time data from the source (your CRM)
  const currentMQLCount = await crmApi.getMQLCountForQuarter('Q3 2025');

  // 2. Update the strategic plan programmatically
  await keyResults.update('kr_1', {
    value: currentMQLCount
  });

  console.log(`Key Result 'kr_1' is now synced with CRM data: ${currentMQLCount}`);
}

// Execute the sync
syncMQLsFromCRM();

You can apply the same logic to any measurable goal.

Improve landing page conversion to 5%: Pull data from Google Analytics or Amplitude.
Decrease cost-per-click to $2.50: Pull data from your Google Ads or Facebook Ads API.

This closes the loop. Your strategy dictates the work, and the results of that work automatically flow back to update the strategy in real-time.

The Result: A Central Nervous System for Strategy

By using Plans.do as an integration hub, you create a strategic nervous system for your business.

Top-down signals (Strategy): Plans defined in code trigger and provide context for work in Jira and Asana.
Bottom-up feedback (Execution): Real-world results from your CRM and operational systems automatically update progress against those plans.

This moves your company beyond static goals and into a world of dynamic, responsive, and automated strategic management. You eliminate manual reporting, ensure constant alignment, and finally build an unbreakable link between your vision and your daily execution.