Task Block

The task block defines work items in your roadmap, representing development tasks for entities, sources, reports, and other data platform components.

Purpose

Tasks help you:

• Plan development work in a structured way
• Track what needs to be built and in what order
• Manage dependencies between work items
• Calculate realistic timelines based on estimates
• Assign work to team members
• Monitor progress and status

Syntax

task "Task Name" {
  builds "reference"
  depends_on "Other Task Name"
  assignee = "person-name"
  status = "not-started" | "in-progress" | "completed"
  manual_hours = 120
  notes = "Task notes..."
}

Attributes

Required Attributes

builds

What this task will build - a reference to an entity, source, report, or component.

• Type: String reference
• Required: Yes
• Format:
  • Entity: "Domain.Entity"
  • Source: "SourceName"
  • Report: "ProductName.ReportName"
  • Component: "ProductName.ComponentName"
  • Data Product: "ProductName"

task "Build Customer Entity" {
  builds "Sales.Customer"
}

task "Integrate CRM" {
  builds "Salesforce_API"
}

task "Create Dashboard" {
  builds "Sales Analytics.Revenue Dashboard"
}

Optional Attributes

depends_on

Other tasks that must complete before this task can start.

• Type: String (task name)
• Required: No
• Multiple: Yes (can have multiple dependencies)
• Auto-suggested: Yes, based on entity relationships

task "Build Order" {
  builds "Sales.Order"
  depends_on "Build Customer"      # Manual dependency
  depends_on "Integrate Database"  # Manual dependency
}

Automatic dependency suggestion:

Modality suggests dependencies based on:

• Entity relationships (belongs-to, derived-from, contains)
• Entities used in reports/metrics
• Logical model mappings

# Entity with relationship
entity "Order" {
  type = "entity"
  contains entity.Customer
}

# Suggested dependency:
task "Build Order" {
  builds "Sales.Order"
  depends_on "Build Customer"  # ← Auto-suggested from contains
}

assignee

Person responsible for this task.

• Type: String
• Required: No

task "Build Customer" {
  builds "Sales.Customer"
  assignee = "alice"
}

status

Current status of the task.

• Type: String enum
• Required: No (defaults to "not-started")
• Valid values:
  • "not-started": Task hasn't begun (default)
  • "in-progress": Task is actively being worked on
  • "completed": Task is finished

task "Build Customer" {
  builds "Sales.Customer"
  status = "in-progress"
}

manual_hours

Override the estimated hours from the estimation model.

• Type: Number
• Required: No
• Default: Pulled from corresponding estimate or defaults

task "Build Complex Entity" {
  builds "Analytics.Customer360"
  manual_hours = 200  # Override automatic estimate
  notes = "Known to be more complex than standard estimate"
}

Default hours by type (if no estimate exists):

• Entity: 8 hours
• Source: 8 hours
• Report: 8 hours
• Data Product: 16 hours
• Component (report): 8 hours
• Component (cube): 16 hours
• Component (metric): 4 hours
• Component (reverse-etl): 12 hours
• Component (api): 10 hours
• Component (stream): 14 hours

component_type

For component tasks, specifies the type of component.

• Type: String enum
• Required: Only for component tasks
• Valid values: "report", "cube", "metric", "reverse-etl", "api", "stream"

task "Build Customer API" {
  builds "Customer 360.customer_api"
  component_type = "api"
}

notes

Additional notes, assumptions, or context about the task.

• Type: String
• Required: No

task "Build Customer" {
  builds "Sales.Customer"
  notes = """
    Requires resolution across CRM and billing systems.
    Complex deduplication logic needed.
    Estimated at 120 hours based on previous similar entity.
  """
}

Task Types

Entity Tasks

Build data entities (tables, views, models).

task "Build Customer Entity" {
  builds "Sales.Customer"
  depends_on "Integrate CRM"
  assignee = "alice"
  status = "in-progress"
}

Estimated hours: From entity_estimate or default (8 hours)

Auto-suggested dependencies:

• Tasks for entities in belongs-to relationships
• Tasks for entities in derived-from relationships
• Tasks for entities in contains relationships

Source Tasks

Integrate data sources.

task "Integrate Production Database" {
  builds "PostgreSQL_Production"
  assignee = "bob"
  status = "completed"
}

Estimated hours: From source_estimate or default (8 hours)

Auto-suggested dependencies: None (sources typically have no dependencies)

Report Tasks

Build dashboards and reports.

task "Build Revenue Dashboard" {
  builds "Sales Analytics.Revenue Dashboard"
  depends_on "Build Customer Entity"
  depends_on "Build Order Entity"
  assignee = "charlie"
  status = "not-started"
}

Estimated hours: From report_estimate or default (8 hours)

Auto-suggested dependencies:

• Tasks for entities referenced in report metrics (via uses statements)

Component Tasks

Build specialized data product components.

task "Build Customer API" {
  builds "Customer 360.customer_api"
  component_type = "api"
  depends_on "Build Customer Entity"
  assignee = "diana"
  status = "not-started"
}

Component types and default hours:

• report: 8 hours
• cube: 16 hours
• metric: 4 hours
• reverse-etl: 12 hours
• api: 10 hours
• stream: 14 hours

Auto-suggested dependencies:

• Tasks for entities used in the component

Data Product Tasks

Package complete data products.

task "Launch Sales Analytics" {
  builds "Sales Analytics"
  depends_on "Build Revenue Dashboard"
  depends_on "Build Customer Insights"
  assignee = "eve"
  status = "not-started"
}

Estimated hours: Default (16 hours)

Auto-suggested dependencies: None (manually specify report dependencies)

Scheduling

Tasks are automatically scheduled based on:

1. Dependencies: Tasks start after dependencies complete
2. Team capacity: Based on team size and hours per day
3. Estimated hours: From estimation model or manual override
4. Order: Sequential tasks without dependencies

Scheduling Formula

start_date = MAX(dependency end dates) OR previous task end OR roadmap start

days_required = CEIL(estimated_hours / (team_size * hours_per_day))

end_date = start_date + days_required

Example

Given:

• Team size: 2 people
• Hours per day: 6 hours/person
• Capacity: 12 hours/day

task "Build Customer" {
  builds "Sales.Customer"
  # Estimate: 48 hours
  # Days: CEIL(48/12) = 4 days
  # If start: 2025-01-01, end: 2025-01-05
}

task "Build Order" {
  builds "Sales.Order"
  depends_on "Build Customer"
  # Estimate: 40 hours
  # Days: CEIL(40/12) = 4 days
  # Start: 2025-01-05 (after Customer)
  # End: 2025-01-09
}

Examples

Simple Task

task "Setup Database" {
  builds "PostgreSQL_Production"
  assignee = "alice"
  status = "completed"
}

Task with Dependencies

task "Build Order Entity" {
  builds "Sales.Order"
  depends_on "Setup Database"
  depends_on "Build Customer Entity"
  assignee = "bob"
  status = "in-progress"
  notes = "Order entity references Customer"
}

Task with Manual Override

task "Build Customer 360" {
  builds "Analytics.Customer360"
  manual_hours = 200
  depends_on "Integrate CRM"
  depends_on "Integrate Database"
  depends_on "Integrate Support System"
  assignee = "charlie"
  status = "not-started"
  notes = """
    Complex entity requiring resolution across 3 systems.
    Previous similar entity took 180 hours.
    Adding buffer for unknowns.
  """
}

Complete Task Chain

# Foundation
task "Setup Infrastructure" {
  builds "AWS_Infrastructure"
  manual_hours = 40
  assignee = "alice"
  status = "completed"
}

# Data sources
task "Integrate CRM" {
  builds "Salesforce_API"
  depends_on "Setup Infrastructure"
  assignee = "bob"
  status = "completed"
}

task "Integrate Database" {
  builds "PostgreSQL_Production"
  depends_on "Setup Infrastructure"
  assignee = "alice"
  status = "completed"
}

# Core entities
task "Build Customer" {
  builds "Sales.Customer"
  depends_on "Integrate CRM"
  depends_on "Integrate Database"
  assignee = "bob"
  status = "in-progress"
}

task "Build Product" {
  builds "Sales.Product"
  depends_on "Integrate Database"
  assignee = "charlie"
  status = "in-progress"
}

task "Build Order" {
  builds "Sales.Order"
  depends_on "Build Customer"
  depends_on "Build Product"
  depends_on "Integrate Database"
  assignee = "bob"
  status = "not-started"
}

# Reports
task "Revenue Dashboard" {
  builds "Sales Analytics.Revenue Dashboard"
  depends_on "Build Customer"
  depends_on "Build Order"
  assignee = "diana"
  status = "not-started"
}

task "Product Performance" {
  builds "Sales Analytics.Product Dashboard"
  depends_on "Build Product"
  depends_on "Build Order"
  assignee = "diana"
  status = "not-started"
}

# Final product
task "Launch Sales Analytics" {
  builds "Sales Analytics"
  depends_on "Revenue Dashboard"
  depends_on "Product Performance"
  assignee = "alice"
  status = "not-started"
}

Best Practices

1. Use Clear, Action-Oriented Names

// Good
task "Build Customer Entity"
task "Integrate CRM Source"
task "Create Revenue Dashboard"

// Avoid
task "Customer"
task "CRM"
task "Dashboard"

2. Document Dependencies

Explain why dependencies exist:

task "Build Order Entity" {
  builds "Sales.Order"
  depends_on "Build Customer"
  depends_on "Build Product"
  notes = "Order references both Customer and Product foreign keys"
}

3. Track Progress in Notes

Use notes for status updates:

task "Build Customer 360" {
  builds "Analytics.Customer360"
  status = "in-progress"
  notes = """
    Week 1: Data source integration (done)
    Week 2: Resolution logic (in progress)
    Week 3: Testing (not started)
    Current blocker: Waiting on CRM API access
  """
}

4. Override Estimates When Justified

Use manual hours when you have better information:

task "Migrate Legacy System" {
  builds "Legacy.MainframeData"
  manual_hours = 300
  notes = "Previous migration took 4 weeks. Complex COBOL logic."
}

5. Assign Early

Assign tasks to distribute work:

task "Build Customer" {
  builds "Sales.Customer"
  assignee = "alice"  # Entity modeling specialist
}

task "Revenue Dashboard" {
  builds "Analytics.Revenue Dashboard"
  assignee = "bob"  # BI specialist
}

6. Update Status Regularly

Keep status current for accurate progress tracking:

task "Build Order" {
  builds "Sales.Order"
  status = "in-progress"  # Update as work progresses
  notes = "60% complete - all fields mapped, testing remaining"
}

7. Structure for Parallelism

Avoid unnecessary dependencies to enable parallel work:

// Good - parallel work
task "Build Customer" {
  builds "Sales.Customer"
  assignee = "alice"
}

task "Build Product" {
  builds "Sales.Product"
  assignee = "bob"  # Can work simultaneously
}

// Avoid - artificial sequencing
task "Build Product" {
  builds "Sales.Product"
  depends_on "Build Customer"  # Unnecessary if no logical dependency
}

Integration with Estimation

Tasks automatically use estimates from estimation blocks:

# Define estimate
entity_estimate "Sales.Customer" {
  data_quality = "medium"
  data_volume = "large"
  scd_type = "type-2"
  business_rules_complexity = "moderate"
  # ... other attributes
  # Calculated: 120 hours
}

# Task uses estimate
task "Build Customer" {
  builds "Sales.Customer"
  # Automatically uses 120 hours from estimate
}

Override when needed:

task "Build Customer" {
  builds "Sales.Customer"
  manual_hours = 150  # Override the 120 hour estimate
  notes = "Added 30 hours for additional PII compliance work"
}