Developer Handover Pack

Everything needed to build the automation from scratch: current state, full agent specs, data flow, and the build stack.

4 pagesPDF · Technical

FS-DOC-04Technical

Developer Handover Pack

Strategic Planning Workflow

[YourCompany.com] · Management Department · Prepared by FullSpec · [Today's Date]

This document gives the FullSpec build team everything needed to implement, configure, and hand over the Strategic Planning Workflow automation. It covers the current-state step map with bottleneck flags, full agent specifications with IO contracts, the end-to-end data flow trace, and the recommended build stack. The owner's responsibilities are limited to reviewing and approving the consolidated plan in Notion; every other step described here is handled by the automation. Questions about this document should be directed to support@gofullspec.com.

01Process snapshot

Step

Name

Description

Initiate Planning Cycle

Owner manually drafts and sends a kickoff email to each department head via Google Workspace announcing the cycle and listing required inputs. Written from scratch each quarter. Time cost: 30 min.

Share Goal Submission Templates

A Google Sheets or Notion template is manually duplicated and shared with each department head, with links pasted into the kickoff email or sent separately. Time cost: 25 min.

Chase Late Submissions

One week before the deadline, the coordinator manually checks which teams have submitted and sends follow-up Slack messages or emails. Multiple rounds are typically required. Time cost: 45 min.

Pull Financial and Sales Data

The finance lead exports revenue, pipeline, and expense figures from source systems and pastes them into the master planning spreadsheet. Formatting and alignment add further time. Time cost: 60 min.

Consolidate Department Inputs

Submitted goals and initiatives are manually copied into a central Notion page. Duplicates, overlaps, and inconsistent formatting are corrected by hand. Time cost: 75 min.

Validate Goals Against Prior Quarter

The owner manually compares current goals against last quarter's outcomes by switching between documents and flags any missed targets. Time cost: 40 min.

Draft Strategy Summary Document

A written plan summary covering top priorities, key metrics, and team commitments is drafted in Google Docs, usually by editing a prior quarter's version. Time cost: 90 min.

Distribute Final Plan to Leadership

The finished strategy document is shared via Slack or email; the owner manually notifies each team lead and confirms access to the correct version. Time cost: 20 min.

Run Weekly Progress Check-ins

Each week throughout the quarter the owner manually sends requests to department heads for goal progress updates. Responses arrive in varied formats and typically require chasing. Time cost: 40 min.

Compile Weekly Progress Report

Responses from department heads are manually assembled into a summary report, with charts and comparisons updated by hand before distribution. Time cost: 55 min.

Time cost summary: total manual time per planning cycle initiation is approximately 480 minutes (8 hours) across all 10 steps. The weekly recurring cost for steps 9 and 10 is 95 minutes per week. At 4 cycles per year with weekly check-ins running across roughly 12 weeks per quarter, this compounds to approximately 7 hours of senior time consumed per week when averaged across the year. The automation fully replaces steps 2, 4, and 5 (Planning Data Agent) and steps 9 and 10 (Progress Tracking Agent), eliminating the four highest-cost and highest-frequency bottleneck steps from the manual process.

Developer Handover PackPage 1 of 4

FS-DOC-04Technical

02Agent specifications

Planning Data Agent

Handles all data gathering and consolidation tasks at the start of each planning cycle. On trigger, the agent duplicates the standard Notion goal submission template for every active department, writes the correct team name and quarter label into each page, posts a direct Slack message to each department head with the page link and deadline, queries Google Sheets and HubSpot for current financial and pipeline figures, and writes those values into the master strategy Notion page. Forty-eight hours before the submission deadline it re-queries Notion to identify incomplete pages and sends a targeted Slack reminder only to those departments. Once the deadline passes, it reads all completed pages and merges them into the master Notion page, flagging any still-incomplete submissions for owner review. Estimated build time: 20 hours. Complexity: Moderate.

Trigger

Scheduled date-based trigger firing at the configured planning cycle start date; secondary cron trigger firing 48 hours before the submission deadline for reminder dispatch.

Tools

Notion, Google Sheets, HubSpot, Slack

Replaces steps

Step 2 (Share Goal Submission Templates), Step 4 (Pull Financial and Sales Data), Step 5 (Consolidate Department Inputs)

Estimated build

20 hours / Moderate

// Input
cycle_start_date: ISO 8601 date string from scheduler
quarter_label: string  e.g. 'Q3 2025'
department_list: array of { dept_id, dept_name, slack_user_id, notion_template_page_id }
submission_deadline: ISO 8601 date string
// Google Sheets pull
sheets_range: 'FinancialSummary!B2:E10'  -> revenue_ytd, pipeline_value, expenses_ytd, gross_margin
// HubSpot pull
hubspot_endpoint: GET /crm/v3/objects/deals  filter: stage=closedwon, closedate=current_quarter
hubspot_fields: [ 'amount', 'closedate', 'pipeline' ]  -> total_closed_revenue, open_pipeline_value
// Output
notion_submission_pages: array of { dept_name, page_id, page_url, status: 'created' }
slack_kickoff_messages: array of { slack_user_id, message_ts, delivery_status }
slack_reminder_messages: array of { slack_user_id, message_ts, delivery_status }  // 48-hr reminder only
master_notion_page_id: string  // updated with financial data and merged dept inputs
consolidation_report: { complete_count, incomplete_depts: array of dept_name, merged_at: ISO 8601 }

Notion tier must support API access (Notion Business or above required for database duplication via API). Confirm workspace plan before build starts.
The Notion template page ID for goal submissions must be pinned in the credential store. The agent duplicates this page, not a database entry; confirm the template lives in a shared workspace accessible to the automation integration user.
Department list (dept_id, dept_name, slack_user_id, notion_template_page_id) must be maintained as a config object in the orchestration layer, not hard-coded. This allows the owner to add or remove contributors without a code change.
HubSpot field names for pipeline and revenue vary between accounts. The fields 'amount', 'closedate', and 'pipeline' must be confirmed against the live HubSpot instance before build. The deal stage filter value ('closedwon') must also be verified as it is case-sensitive.
Google Sheets range 'FinancialSummary!B2:E10' is illustrative. The exact sheet name, tab name, and cell range must be confirmed with the Finance Lead before build. If the sheet structure changes, the agent will silently pull incorrect data without a schema validation step.
Dedupe logic: if a submission Notion page already exists for a department in the current quarter (identified by quarter_label property match), the agent must skip creation and log a warning rather than duplicate the page.
Fallback behaviour for HubSpot timeout or Google Sheets read failure: the agent must post an alert to the designated Slack error channel, write a failure record to the error log table, and continue with the rest of the cycle using null values for the affected fields, clearly marking them as unresolved in the master Notion page.
Slack kickoff and reminder messages must use a pinned message template stored in the orchestration config. Do not hard-code message text in the workflow itself.
The 48-hour reminder cron must only fire if at least one submission page has a status property value other than 'complete'. Add a gate check before the Slack dispatch step.
Owner approval notification (Slack message prompting review in Notion) is triggered by the consolidation completion event, not by this agent directly. Confirm whether this notification is handled inline here or by a separate lightweight workflow step.

Progress Tracking Agent

Manages the ongoing weekly check-in loop for the duration of each active planning quarter. Every Monday morning the agent sends a structured Slack message to each department head prompting them to update their goal status in their Notion submission page. Later that day, or at a configured read-back time, the agent queries each Notion page for updated status property values and completion percentages, calculates an overall completion rate per department and in aggregate, and posts a formatted progress summary to the designated leadership Slack channel. If a department head has not updated their page by the read-back window, the agent flags that department as unresponsive in the report rather than omitting them. Estimated build time: 14 hours. Complexity: Moderate.

Trigger

Recurring cron schedule every Monday at 08:00 in the owner's configured timezone, active only while a planning cycle status flag in Notion is set to 'active'.

Tools

Notion, Slack

Replaces steps

Step 9 (Run Weekly Progress Check-ins), Step 10 (Compile Weekly Progress Report)

Estimated build

14 hours / Moderate

// Input
cycle_status_page_id: string  // Notion page where active cycle flag is stored
cycle_active_flag: boolean  // agent exits if false
quarter_label: string  // used to scope the correct set of submission pages
department_list: array of { dept_id, dept_name, slack_user_id, notion_page_id }
read_back_time: string  // e.g. '14:00' local timezone, configurable in orchestration config
leadership_slack_channel_id: string  // destination for weekly report post
// Notion read per dept page
notion_page_properties: { goal_status: enum['not_started','in_progress','complete','at_risk'], completion_pct: number 0-100, last_updated: ISO 8601 }
// Output
slack_checkin_messages: array of { slack_user_id, message_ts, delivery_status }
progress_report: { week_number, quarter_label, dept_summaries: array of { dept_name, goal_status, completion_pct, responsive: boolean }, overall_completion_pct: number, generated_at: ISO 8601 }
slack_report_post: { channel_id: leadership_slack_channel_id, message_ts, delivery_status }
// On approval (plan distribution step, handled by orchestration layer post owner approval)
distribution_trigger: { approved_by: slack_user_id, approved_at: ISO 8601, master_notion_page_url: string }
slack_distribution_messages: array of { slack_user_id, message_ts, delivery_status }

The cycle_active_flag must be the first thing the agent checks on each Monday run. If the flag is false or the Notion read fails, the agent must exit cleanly and log a skipped-run record. Do not post a partial report.
Notion goal pages must have a standardised property schema: 'goal_status' (select), 'completion_pct' (number), 'last_updated' (date). This schema must be confirmed and applied to all department pages before the Progress Tracking Agent build begins. Pages missing these properties will return null values and cause report formatting errors.
The leadership Slack channel ID must be stored in the orchestration config. Do not hard-code. Confirm the bot has been added to that channel with chat:write scope before deployment.
The Slack check-in message template must include a direct link to the department's Notion page and a plain-language prompt. Store the template in the orchestration config, not in the workflow code.
If a department Notion page returns a last_updated timestamp older than 7 days at the read-back window, mark that department as unresponsive: true in the report and display it with a visual flag in the Slack report block (amber emoji or bold label).
The weekly report Slack post must use Slack Block Kit formatting for readability. Design and pin the Block Kit JSON template in the orchestration config. Avoid plain-text concatenation for the report body.
overall_completion_pct is calculated as the mean of all responsive department completion_pct values. Unresponsive departments are excluded from the mean but listed separately in the report.
Timezone handling: the Monday 08:00 cron must use the owner's configured IANA timezone string (e.g. 'America/New_York'). Store this in the orchestration config. Do not assume UTC.
The plan distribution Slack messages (post owner approval) should be handled by the orchestration layer as a discrete step triggered by the Notion approval flag update, not by this agent's Monday cron. Confirm the handoff boundary before build.

Developer Handover PackPage 2 of 4

FS-DOC-04Technical

03End-to-end data flow

Full trigger-to-output data flow for the Strategic Planning Workflow. Field names are indicative pending confirmation of live Google Sheets range, HubSpot deal stage values, and Notion database schema.

// ============================================================
// STRATEGIC PLANNING WORKFLOW  -  END-TO-END DATA FLOW
// ============================================================

// TRIGGER
// Scheduled date-based trigger fires at cycle_start_date (ISO 8601)
TRIGGER.scheduled_date -> orchestration_layer
  fields: { cycle_start_date, quarter_label, submission_deadline }

// ============================================================
// AGENT HANDOFF 1: PLANNING DATA AGENT  -  TEMPLATE CREATION
// ============================================================
orchestration_layer -> Planning_Data_Agent.create_submission_pages
  input: {
    quarter_label: string,
    department_list: [{ dept_id, dept_name, slack_user_id, notion_template_page_id }],
    submission_deadline: ISO 8601
  }
  action: Notion API POST /pages  (duplicate template per department)
  dedupe_check: Notion query filter { quarter_label == current, dept_id == dept_id }
  output: {
    notion_submission_pages: [{ dept_name, page_id, page_url, status: 'created' }]
  }

// PLANNING DATA AGENT  -  KICKOFF NOTIFICATIONS
Planning_Data_Agent.create_submission_pages -> Planning_Data_Agent.send_kickoff_slack
  input: {
    department_list: [{ dept_name, slack_user_id }],
    notion_submission_pages: [{ dept_name, page_url }],
    submission_deadline: ISO 8601
  }
  action: Slack API POST /chat.postMessage  (one message per dept head)
  message_template: config.kickoff_message_template
  output: {
    slack_kickoff_messages: [{ slack_user_id, message_ts, delivery_status }]
  }

// PLANNING DATA AGENT  -  FINANCIAL AND PIPELINE DATA PULL
Planning_Data_Agent.send_kickoff_slack -> Planning_Data_Agent.pull_financial_data
  action_1: Google Sheets API GET
    range: 'FinancialSummary!B2:E10'
    output_fields: { revenue_ytd, pipeline_value, expenses_ytd, gross_margin }
  action_2: HubSpot CRM API GET /crm/v3/objects/deals
    filter: { stage: 'closedwon', closedate: current_quarter }
    fields: [ 'amount', 'closedate', 'pipeline' ]
    output_fields: { total_closed_revenue, open_pipeline_value }
  on_error: write to error_log_table; post alert to config.error_slack_channel_id
  -> Planning_Data_Agent.write_financial_to_notion
  action: Notion API PATCH /pages/{master_notion_page_id}
    properties: { revenue_ytd, pipeline_value, expenses_ytd, gross_margin,
                  total_closed_revenue, open_pipeline_value }
  output: { master_notion_page_id: string, financial_write_status: 'success'|'partial'|'failed' }

// PLANNING DATA AGENT  -  48-HOUR DEADLINE REMINDER
cron_trigger (deadline - 48h) -> Planning_Data_Agent.check_incomplete_pages
  action: Notion API POST /databases/{submission_db_id}/query
    filter: { quarter_label == current, status != 'complete' }
  output: { incomplete_depts: [{ dept_name, slack_user_id, page_id }] }
  gate: if incomplete_depts.length == 0 -> exit, no reminder sent
  -> Planning_Data_Agent.send_reminder_slack
  action: Slack API POST /chat.postMessage  (targeted to incomplete depts only)
  message_template: config.reminder_message_template
  output: { slack_reminder_messages: [{ slack_user_id, message_ts, delivery_status }] }

// PLANNING DATA AGENT  -  CONSOLIDATION INTO MASTER NOTION PAGE
cron_trigger (submission_deadline) -> Planning_Data_Agent.consolidate_inputs
  action: Notion API POST /databases/{submission_db_id}/query
    filter: { quarter_label == current }
  fields_read_per_page: { dept_name, goals: array, initiatives: array,
                          goal_status, completion_pct, last_updated }
  output: {
    complete_depts: [{ dept_name, goals, initiatives, goal_status, completion_pct }],
    incomplete_depts: [{ dept_name }]
  }
  -> Planning_Data_Agent.write_consolidated_to_master
  action: Notion API PATCH /pages/{master_notion_page_id}
    append_blocks: merged dept goals, initiatives, financial summary
    flag_incomplete: incomplete_depts listed with 'AWAITING INPUT' label
  output: {
    consolidation_report: { complete_count, incomplete_depts, merged_at: ISO 8601 }
    master_notion_page_id: string
  }

// ORCHESTRATION LAYER  -  OWNER APPROVAL NOTIFICATION
Planning_Data_Agent.write_consolidated_to_master -> orchestration_layer.notify_owner_approval
  action: Slack API POST /chat.postMessage -> config.owner_slack_user_id
  message: 'Planning cycle consolidated. Review and approve in Notion: {master_notion_page_url}'
  output: { approval_notification_ts: string, delivery_status }

// MANUAL STEP  -  OWNER REVIEWS AND APPROVES IN NOTION
owner -> Notion page: sets property approval_status = 'approved'
  monitored_by: orchestration_layer polling Notion GET /pages/{master_notion_page_id}
  poll_interval: 30 minutes
  fields_checked: { approval_status: enum['pending','approved','revision_requested'] }

// ORCHESTRATION LAYER  -  DISTRIBUTE APPROVED PLAN
orchestration_layer.detect_approval -> orchestration_layer.distribute_plan
  trigger_condition: approval_status == 'approved'
  input: { master_notion_page_url, quarter_label, approved_by, approved_at }
  action: Slack API POST /chat.postMessage -> all leadership_team slack_user_ids
  message_template: config.distribution_message_template
  output: { slack_distribution_messages: [{ slack_user_id, message_ts, delivery_status }] }

// ============================================================
// AGENT HANDOFF 2: PROGRESS TRACKING AGENT  -  WEEKLY LOOP
// ============================================================
cron_trigger (every Monday 08:00 owner_timezone) -> Progress_Tracking_Agent.gate_check
  action: Notion API GET /pages/{cycle_status_page_id}
  field_checked: { cycle_active_flag: boolean }
  if cycle_active_flag == false -> exit, log skipped_run

Progress_Tracking_Agent.gate_check -> Progress_Tracking_Agent.send_checkin_slack
  input: {
    department_list: [{ dept_name, slack_user_id, notion_page_id }],
    quarter_label: string
  }
  action: Slack API POST /chat.postMessage  (one per dept head)
  message_template: config.checkin_message_template  // includes notion_page link
  output: { slack_checkin_messages: [{ slack_user_id, message_ts, delivery_status }] }

cron_trigger (every Monday config.read_back_time) -> Progress_Tracking_Agent.read_notion_pages
  action: Notion API POST /databases/{submission_db_id}/query
    filter: { quarter_label == current }
    fields: { dept_name, goal_status, completion_pct, last_updated }
  responsive_check: last_updated >= (today - 7 days) -> responsive: true, else false
  output: {
    dept_summaries: [{ dept_name, goal_status, completion_pct, responsive }]
  }

Progress_Tracking_Agent.read_notion_pages -> Progress_Tracking_Agent.compile_report
  calculation: overall_completion_pct = mean(completion_pct) where responsive == true
  unresponsive_depts: listed separately in report with flag
  output: {
    progress_report: { week_number, quarter_label, dept_summaries,
                       overall_completion_pct, generated_at: ISO 8601 }
  }

Progress_Tracking_Agent.compile_report -> Progress_Tracking_Agent.post_slack_report
  action: Slack API POST /chat.postMessage -> config.leadership_slack_channel_id
  format: Slack Block Kit JSON  (template pinned in orchestration config)
  output: { slack_report_post: { channel_id, message_ts, delivery_status } }

// ============================================================
// ERROR LOGGING  -  ALL AGENTS
// ============================================================
on_error (any agent) -> error_log_table.insert
  fields: { agent_name, step_name, error_type, error_message, timestamp, cycle_id }
  alert: Slack API POST /chat.postMessage -> config.error_slack_channel_id
// ============================================================

Developer Handover PackPage 3 of 4

FS-DOC-04Technical

04Recommended build stack

Orchestration layer

A workflow automation tool managing two discrete workflows: one per agent (Planning Data Agent workflow, Progress Tracking Agent workflow). Both workflows share a single credential store for Notion, Google Sheets, HubSpot, and Slack. A third lightweight workflow handles the owner approval polling loop and plan distribution step. All message templates, department lists, channel IDs, and configurable schedule values are stored as environment-level variables in the orchestration platform, not hard-coded in workflow nodes.

Webhook configuration

No inbound webhooks are required for this process. All triggers are outbound: a date-based scheduled trigger for cycle start, a cron trigger for the 48-hour reminder, a cron trigger for the submission deadline consolidation, and a recurring Monday cron for the progress tracking loop. The approval detection mechanism uses polling (Notion GET /pages at 30-minute intervals) rather than a Notion webhook, which avoids the need for a public webhook endpoint. If a Notion webhook becomes available and stable on the configured workspace tier, polling can be replaced in a later iteration.

Templating approach

All Slack message text (kickoff, reminder, check-in, report, distribution, error alert) is stored as named templates in the orchestration config. Slack Block Kit JSON for the weekly progress report is maintained as a separate pinned template with variable interpolation for dept_name, completion_pct, goal_status, overall_completion_pct, week_number, and quarter_label. Notion page content written during consolidation uses a predefined block structure appended via the Notion API append_block_children endpoint, not free-text insertion, to ensure consistent page formatting across cycles.

Error logging

All agent errors are written to a dedicated Supabase table (table name: planning_automation_errors) with columns: id (uuid), agent_name (text), step_name (text), error_type (text), error_message (text), cycle_id (text), created_at (timestamptz). On any error insertion, the orchestration layer immediately posts an alert to the Slack channel identified by config.error_slack_channel_id. The error table is readable by the FullSpec team via a read-only Supabase service role key stored in the shared credential store. Non-critical warnings (e.g. dedupe skip, unresponsive department flag) are written to a separate planning_automation_warnings table with the same schema.

Testing approach

All agent workflows are built and validated in a sandbox environment before any connection to live Notion workspaces, HubSpot accounts, or Slack channels. Sandbox testing uses a dedicated Notion test workspace, a cloned Google Sheet with sample financial data, a HubSpot sandbox account with dummy deals, and a private Slack test channel. The Planning Data Agent is tested with a four-department scenario including one incomplete submission and one HubSpot API timeout simulation. The Progress Tracking Agent is tested across three Monday cycles with mixed responsive and unresponsive department states. End-to-end testing on the live environment is performed with a single test department before the full contributor list is activated.

Estimated total build time

Planning Data Agent: 20 hours. Progress Tracking Agent: 14 hours. End-to-end integration testing, approval flow, error logging, and deployment: 4 hours. Total: 38 hours. This matches the confirmed build_effort_hours in the process specification. The Standard build timeline is 3 to 4 weeks, with pre-build Notion schema confirmation and credential provisioning on the critical path.

Pre-build blockers that must be resolved before any workflow node is created: (1) Notion workspace plan confirmed as Business or above with API access enabled. (2) Notion goal submission template page ID provided and schema standardised with goal_status, completion_pct, and last_updated properties on all department pages. (3) HubSpot deal stage filter value and pipeline field names confirmed against the live account. (4) Google Sheets tab name, sheet name, and financial data cell range confirmed with the Finance Lead. (5) Slack bot installed in all relevant channels (department head DMs, leadership channel, error channel) with chat:write and channels:read scopes. (6) Owner Slack user ID and leadership team Slack user IDs provided for config. Contact support@gofullspec.com to provide credentials and confirm these items before build week 2 begins.

Developer Handover PackPage 4 of 4

Developer Handover Pack