Task Template Builder – Generate Workflow & Project Task Templates

Task Template Builder is an Apify Actor that turns a list of task definitions into reusable templates — checklists, SOPs, project-style specs, automation JSON, or hybrid Markdown + JSON. Generation is rule-based (no LLM or paid external APIs). Export rows to the default dataset as JSON, CSV, or Excel, or save a combined bundle to the key-value store.

Overview

Each run processes your tasks array, classifies each item by keywords, and emits structured template content with steps, acceptance criteria, dependencies, and automation hints.

• Batch generation — many templates in one run (capped by maxTasks)
• Five template modes — checklist, SOP, project task, automation JSON, or hybrid
• Configurable sections — toggle subtasks, criteria, dependencies, tags, and more
• Dual output — per-row dataset and optional combined KV export
• No API keys — deterministic, built-in logic only

Quick start

1. Open Task Template Builder on Apify and paste your tasks array (each item needs at least title or goal).
2. Choose templateMode (default hybrid) and outputStyle (default both).
3. Set outputMode to dataset, kv_store, or both.
4. Click Run — inspect the Dataset tab for one row per template.
5. Download CSV/JSON/Excel from Console or use the dataset API link in the actor Output schema.

Minimal input example (prefilled Try actor)

{
  "tasks": [
    {
      "title": "Follow up with new lead after demo",
      "goal": "Send a structured follow-up after a product demo",
      "category": "sales",
      "priorityHint": "high"
    },
    {
      "title": "Publish weekly blog post",
      "goal": "Write and publish this week's blog post on schedule",
      "category": "content"
    }
  ],
  "templateMode": "hybrid",
  "outputStyle": "both",
  "outputMode": "dataset"
}

Input configuration

Field	Required	Description
tasks	Yes	Array of task objects. Each needs at least title or goal. Optional: category, context, priorityHint, estimatedMinutes, recurrenceHint, ownerRole, department, inputNotes.
templateMode	No	checklist, sop, project_task, automation_json, or hybrid (default).
outputStyle	No	structured_json, markdown_like, or both (default).
outputMode	No	dataset (default), kv_store, or both.
outputKvStoreKey	No	Secret. KV record name for combined export (prefill TASK_TEMPLATE_OUTPUT; Actor default when empty).
maxTasks	No	Max tasks per run (default 100, max 1000).
includeSubtasks	No	Generate subtask items (default true).
includeAcceptanceCriteria	No	Generate completion conditions (default true).
includeDependencies	No	Generate prerequisite dependencies (default true).
includeRecurrenceSuggestion	No	Suggest recurrence pattern (default true).
includeAutomationHints	No	Suggest automation opportunities (default true).
includeTimeEstimate	No	Estimate minutes to complete (default true).
includeRoleSuggestion	No	Suggest owner role and department (default true).
includeTags	No	Generate descriptive tags (default true).
normalizePriority	No	Map hints to low / medium / high / urgent (default true).
includeDebugFields	No	Add classification/debug metadata (default false).

Full input example (KV export + section toggles)

{
  "tasks": [
    {
      "title": "Onboard new employee",
      "goal": "Complete first-week onboarding checklist",
      "category": "hr",
      "recurrenceHint": "on_new_record",
      "ownerRole": "HR Coordinator"
    },
    {
      "title": "Weekly sales pipeline review",
      "goal": "Review open deals and update CRM",
      "category": "sales",
      "recurrenceHint": "weekly",
      "priorityHint": "medium"
    }
  ],
  "templateMode": "sop",
  "outputStyle": "both",
  "outputMode": "both",
  "outputKvStoreKey": "TASK_TEMPLATE_OUTPUT",
  "maxTasks": 100,
  "includeSubtasks": true,
  "includeAcceptanceCriteria": true,
  "includeDependencies": true,
  "includeAutomationHints": true,
  "includeDebugFields": false
}

Output

Dataset (one row per template or error)

When outputMode is dataset or both, the Actor pushes task_template and __error__ rows. Run summary counts are logged and included in the KV export — not as a separate dataset row.

Field	Description
type	task_template or __error__
inputTitle / normalizedTitle	Original and cleaned task title
goal / category / taskType	Purpose, category, and inferred classification
templateMode / description	Mode used and short summary
ownerRole / department / priority	Suggested ownership and priority
estimatedMinutes	Time estimate when enabled
steps[] / subtasks[]	Ordered steps and optional subtasks
acceptanceCriteria[] / dependencies[]	Completion rules and prerequisites
requiredInputs[] / automationHints[]	Inputs needed and automation suggestions
recurrenceSuggestion / tags[]	Recurrence and tags
markdownTemplate / jsonTemplate	Human-readable and structured formats (per outputStyle)
error / errorType	Error message on failed rows
timestamp	ISO-8601 generation time

Example dataset row

{
  "type": "task_template",
  "inputTitle": "Follow up with new lead after demo",
  "normalizedTitle": "Follow up with new lead after demo",
  "goal": "Send a structured follow-up after a product demo",
  "category": "sales",
  "taskType": "follow_up",
  "templateMode": "hybrid",
  "priority": "high",
  "ownerRole": "Account Manager",
  "department": "Sales",
  "estimatedMinutes": 30,
  "steps": [
    { "stepNumber": 1, "title": "Review demo notes", "details": "..." }
  ],
  "acceptanceCriteria": ["Follow-up email sent within 24 hours"],
  "markdownTemplate": "# Follow up with new lead after demo\n\n...",
  "jsonTemplate": { "templateKind": "hybrid", "title": "..." },
  "timestamp": "2026-06-06T12:00:00+00:00"
}

Key-value store export

When outputMode is kv_store or both, a combined JSON file is saved under outputKvStoreKey (default TASK_TEMPLATE_OUTPUT) containing templates, summary, and metadata. Use the actor Output schema in Console for direct API links.

How it works

1. Parse and validate the tasks array (respecting maxTasks).
2. Classify each task using keyword rules (follow-up, content, onboarding, support, sales, etc.).
3. Generate steps, subtasks, acceptance criteria, dependencies, and hints from task type and category.
4. Render markdownTemplate and/or jsonTemplate per outputStyle and templateMode.
5. Push each template (or error row) to the dataset when configured.
6. Optionally write the full bundle to the key-value store.

Template modes

templateMode	Best for
checklist	Quick bullet checklists
sop	Step-by-step standard operating procedures
project_task	Project-management-oriented fields
automation_json	Machine-friendly automation payloads
hybrid	Structured JSON plus Markdown overview (default)

Sensitive input

outputKvStoreKey is marked as a secret input (isSecret: true). It is the KV record name for combined export — not an encryption key. Secret values are encrypted in Apify storage and are not written to dataset rows.

Best practices

• Provide both title and goal when possible — classification and steps improve with clearer intent.
• Set category (sales, marketing, hr, support, content, etc.) for better role and department suggestions.
• Use hybrid + both when you need Markdown for humans and JSON for automation.
• Use outputMode: both when downstream tools consume the KV bundle while you browse rows in the dataset.
• Review generated SOPs before deploying — templates are starting points, not compliance-approved final documents.

Use cases

• Agency playbooks — client onboarding, campaign launches, SEO sprints
• HR and recruiting — onboarding checklists, interview workflows
• Sales motions — follow-up sequences, pipeline review cadences
• Support SOPs — ticket handling and escalation runbooks
• Operations — recurring admin routines and reporting templates

Limitations

• Rule-based only — no LLM; outputs use built-in archetypes, not custom org-specific legal text.
• English outputs today.
• Not a task manager — generates template content; does not create live tasks in Asana, Jira, etc.
• No built-in PM connectors — export Markdown/JSON/CSV and import into your tools manually or via your own automation.

FAQ

Does this replace Asana, Linear, or Jira?

No. It generates reusable template content you paste, import, or automate elsewhere.

Can I generate multiple templates in one run?

Yes. Pass multiple objects in the tasks array (up to maxTasks).

What if one task fails?

That task gets a __error__ row; other tasks still process.

Where is the combined export?

In the run’s default key-value store under outputKvStoreKey when outputMode is kv_store or both.

Do I need API keys?

No. All generation is deterministic rule-based logic inside the Actor.

How do I integrate with Notion or ClickUp?

Copy markdownTemplate from dataset rows, or consume the KV JSON export via Apify API and map fields in your own integration.

Run locally

1. cd task-template-builder
2. pip install -r requirements.txt
3. Create INPUT.json in this folder (see examples above).
4. apify run or python main.py

Deploy

Push with Apify CLI or connect the Git repository (task-template-builder/ directory). Schema files: INPUT_SCHEMA.json, OUTPUT_SCHEMA.json, .actor/dataset_schema.json, Dockerfile.

Get started

Paste your tasks list, choose hybrid and both for maximum flexibility, run on Apify, and download templates from the Dataset tab or KV export.