Parse: Accomplished X. Next: Y. Blockers: Z

Tracking goals and Key Results weekly across distributed teams requires tools that balance visibility with low overhead. The best solution depends on your team’s existing workflow, technical sophistication, and whether you need deep integration with your development pipeline.

What Makes a Good Weekly Goal Tracker for Remote Teams

For remote engineering teams, weekly goal tracking differs from quarterly OKR management. You need something that captures:

What each team member accomplished this week
What they’re working on next
Blockers and dependencies across time zones
Alignment with larger quarterly objectives

The tool should require minimal friction. If updating goals takes more than two minutes, adoption drops. Look for keyboard-first interfaces, API access for automation, and async-first design that doesn’t assume everyone is online simultaneously.

Linear: Cycles and Issues Combined

Linear combines issue tracking with cycle-based planning, making it strong for teams already using it for project management. Each cycle (typically two weeks) functions as a goal container, and you can create issues specifically for objectives.

{
  "title": "Q1 Objective: Improve API Response Time",
  "description": "Reduce average API response time by 40%",
  "teamId": "team_123",
  "children": [
    {
      "title": "KR1: Optimize database queries",
      "targetValue": 100,
      "unit": "percent"
    },
    {
      "title": "KR2: Add caching layer",
      "targetValue": 200,
      "unit": "ms reduction"
    }
  ]
}

Linear’s GraphQL API lets you query cycle progress programmatically. Here’s how to fetch all issues completed in the current cycle:

query GetCycleProgress($cycleId: String!) {
  cycle(id: $cycleId) {
    name
    startsAt
    endsAt
    issues(filter: { state: { name: { eq: "Done" } } }) {
      nodes {
        title
        estimate
        completedAt
      }
    }
  }
}

The limitation: Linear is primarily an issue tracker. True OKR functionality requires workarounds or third-party integrations.

Notion: Flexible Database Architecture

Notion’s database system provides unmatched flexibility for building custom weekly goal trackers. You can create databases for objectives, key results, and weekly check-ins, then link them together.

For a weekly goal tracker, create three interconnected databases:

Objectives Database
├── Title: Increase customer retention
├── Quarter: Q1 2026
├── Owner: @sarah
└── Key Results: [linked KR database]

Key Results Database
├── Title: Reduce churn to under 5%
├── Target: 5
├── Current: 7.2
├── Progress: 61%
└── Weekly Updates: [linked update database]

Weekly Updates Database
├── Week: Jan 13-17
├── This Week: Deployed retention email sequence
├── Next Week: A/B test pricing page
└── Blockers: None

Notion’s API allows programmatic updates. This script updates a key result’s current value:

const { Client } = require('@notionhq/client');
const notion = new Client({ auth: process.env.NOTION_KEY });

async function updateKeyResult(krPageId, newValue) {
  await notion.pages.update({
    page_id: krPageId,
    properties: {
      'Current': {
        number: newValue
      },
      'Last Updated': {
        date: { new Date().toISOString() }
      }
    }
  });
}

Notion works well when you need custom workflows, but the lack of native OKR templates means building everything from scratch.

GitHub Projects: For Code-First Teams

If your team lives in GitHub, Projects combined with Issues provides a lightweight goal tracking system. You can use milestones for time-bound objectives and labels for categorization.

Create a milestone for your quarterly goal:

gh issue create --title "Q1 Objective: API Performance" \
  --milestone "Q1 2026" \
  --label "objective"

Track key results as issues within the milestone with checkboxes:

## Key Results

- [x] KR1: Reduce p95 response time < 200ms
- [ ] KR2: Add Redis caching layer
- [x] KR3: Implement query optimization

GitHub’s Projects (beta) offers board views and automation:

name: Weekly Goal Automation
on:
  schedule:
    - cron: '0 18 *#1 Friday'  # Every Friday at 6pm

jobs:
  goal-check:
    runs-on: ubuntu-latest
    steps:
      - name: Fetch open goals
        run: |
          gh api graphql -f query='
            query {
              organization(login: "yourorg") {
                projectsV2(number: 1) {
                  items(first: 50) {
                    nodes {
                      content {
                        ... on Issue { title state }
                      }
                      fieldValues(first: 8) {
                        nodes {
                          ... on ProjectV2ItemFieldSingleSelectValue { name }
                        }
                      }
                    }
                  }
                }
              }
            }'

This approach works for teams that prefer keeping everything in GitHub, though it’s less structured for high-level OKR visibility.

Lattice: Dedicated OKR and Goals

Lattice specializes in goals and performance management, offering native OKR functionality, 360-degree feedback, and engagement surveys. The weekly check-in feature aligns with your requirement for regular goal updates.

Key features for remote teams:

Weekly check-ins that link to larger goals
Manager visibility without micromanagement
Anonymous feedback collection
Performance review cycles

The API allows syncing with external systems:

import requests

def create_weekly_check_in(user_id, token, check_in_data):
    url = "https://api.lattice.com/v1/check-ins"
    headers = {
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json"
    }
    payload = {
        "user_id": user_id,
        "week": check_in_data["week"],
        "accomplishments": check_in_data["accomplishments"],
        "priorities_next_week": check_in_data["next_week"],
        "blockers": check_in_data.get("blockers", []),
        "goals": check_in_data["goal_ids"]
    }
    response = requests.post(url, json=payload, headers=headers)
    return response.json()

Lattice requires paid plans for advanced features, and the integration ecosystem isn’t as developer-friendly as Linear or GitHub.

Making Your Choice

Consider these factors when selecting a weekly goal tracking tool:

Existing infrastructure: If you already use Linear for issues, extend it rather than adding another tool. If your team uses Notion for documentation, build your goal tracker there.

Technical sophistication: Code-first teams benefit from GitHub Projects. Teams wanting less configuration might prefer dedicated solutions like Lattice.

Integration needs: Consider what other systems must feed into your goal tracking. Marketing, design, and operations may have different tool preferences.

Update frequency: Some tools excel at daily updates, others at weekly or quarterly cadences. Match the tool’s rhythm to your team’s actual meeting schedule.

Implementation Pattern for Weekly Check-Ins

Regardless of tool, structure weekly check-ins consistently:

## Week of [Date]

### This Week's Focus
- [Specific deliverable]: [Status - Done/In Progress/Blocked]
- [Specific deliverable]: [Status]

### Aligned with Quarterly Goals
- Objective: [Name] → Key Result: [Progress %]

### Next Week
- Priority 1: [Description]
- Priority 2: [Description]

### Blockers
- [None / Blocker description with owner]

This template works across tools and provides consistency even when switching platforms.

Building a Custom Solution

For teams with specific requirements, building a lightweight goal tracker using existing APIs offers maximum control. Combine a simple database (PostgreSQL, Airtable) with a Slack or Discord bot for updates.

A minimal Slack command for weekly updates:

@app.command("/weekly-update")
def weekly_update(ack, respond, command):
    ack()
    user = command["user_name"]
    text = command["text"]

    # Parse: "Accomplished X. Next: Y. Blockers: Z"
    # Store in database
    store_update(user, text)

    respond(f"Updated! View all updates at your-dashboard.com/{user}")

The best tool for tracking remote team goals weekly is the one your team actually uses consistently. Start with low friction, iterate based on what information actually helps coordination, and invest in deeper tooling only when the basics prove insufficient.

Built by theluckystrike — More at zovo.one