M0 Prototype

Status: Complete Date reached: 2026-02-27

Milestone requirements

• Core Dataface concept validated (YAML -> dashboards).
• Prototypes established across all workstreams.
• Testing platform established (unit/integration/visual/JS/eval).
• Docs/spec-as-code flow established.

Milestone tasks

dft core (Sr Engineer Architect)

A runnable prototype path exists for the YAML contract, compiler/normalizer, execution adapters, and release/versioning, with concrete artifacts that prove the flow works end-to-end in the current codebase. Core assumptions are documented, known constraints are explicit, and the team can explain what is real versus mocked without ambiguity.

• ☑ Prototype gaps and follow-on capture — Document top gaps and risks in versioning and migrations that must be addressed next.
• ☑ Prototype implementation path — Implement a runnable end-to-end prototype path for YAML contract and normalizer.
• ☑ Prototype validation and proof — Validate execution/runtime adapters with concrete proof artifacts and repeatable steps.

cloud suite (UI Design and Frontend Dev)

A runnable prototype path exists for hosted user experience for onboarding, sharing, collaboration, and account/project flows, with concrete artifacts that prove the flow works end-to-end in the current codebase. Core assumptions are documented, known constraints are explicit, and the team can explain what is real versus mocked without ambiguity.

• ☑ Prototype gaps and follow-on capture — Document top gaps and risks in account/project lifecycle flows that must be addressed next.
• ☑ Prototype implementation path — Implement a runnable end-to-end prototype path for workspace and onboarding UX.
• ☑ Prototype validation and proof — Validate sharing and collaboration surface with concrete proof artifacts and repeatable steps.

inspect profiler (Sr Engineer Architect)

A runnable prototype path exists for warehouse profiling, semantic inference, and analyst-facing data context surfaces, with concrete artifacts that prove the flow works end-to-end in the current codebase. Core assumptions are documented, known constraints are explicit, and the team can explain what is real versus mocked without ambiguity.

• ☑ Prototype gaps and follow-on capture — Document top gaps and risks in analyst-facing inspector experience that must be addressed next.
• ☑ Prototype implementation path — Implement a runnable end-to-end prototype path for profiling pipeline.
• ☑ Prototype validation and proof — Validate semantic inference and context quality with concrete proof artifacts and repeatable steps.

mcp analyst agent (Data AI Engineer Architect)

A runnable prototype path exists for AI agent tool interfaces, execution workflows, and eval-driven behavior tuning, with concrete artifacts that prove the flow works end-to-end in the current codebase. Core assumptions are documented, known constraints are explicit, and the team can explain what is real versus mocked without ambiguity.

• ☑ Prototype gaps and follow-on capture — Document top gaps and risks in eval and guardrail framework that must be addressed next.
• ☑ Prototype implementation path — Implement a runnable end-to-end prototype path for MCP tool execution model.
• ☑ Prototype validation and proof — Validate agent prompt/workflow behavior with concrete proof artifacts and repeatable steps.

ft dash packs (Data Analysis Evangelist and AI Training)

A runnable prototype path exists for connector-specific dashboard packs and KPI narratives for Fivetran sources, with concrete artifacts that prove the flow works end-to-end in the current codebase. Core assumptions are documented, known constraints are explicit, and the team can explain what is real versus mocked without ambiguity.

• ☑ Prototype gaps and follow-on capture — Document top gaps and risks in pack publishing workflow that must be addressed next.
• ☑ Prototype implementation path — Implement a runnable end-to-end prototype path for connector pack coverage.
• ☑ Prototype validation and proof — Validate dashboard narrative quality with concrete proof artifacts and repeatable steps.

ide extension (Head of Engineering)

A runnable prototype path exists for analyst authoring workflow in VS Code/Cursor with preview, diagnostics, and assist, with concrete artifacts that prove the flow works end-to-end in the current codebase. Core assumptions are documented, known constraints are explicit, and the team can explain what is real versus mocked without ambiguity.

• ☑ Prototype gaps and follow-on capture — Document top gaps and risks in inspector/agent integration in IDE that must be addressed next.
• ☑ Prototype implementation path — Implement a runnable end-to-end prototype path for editor + preview workflow.
• ☑ Prototype validation and proof — Validate IDE diagnostics and guidance with concrete proof artifacts and repeatable steps.

graph library (Data Visualization Designer and Engineer)

A runnable prototype path exists for visual language, chart defaults, interaction behavior, and differentiated styling, with concrete artifacts that prove the flow works end-to-end in the current codebase. Core assumptions are documented, known constraints are explicit, and the team can explain what is real versus mocked without ambiguity.

• ☑ Prototype gaps and follow-on capture — Document top gaps and risks in interaction/accessibility polish that must be addressed next.
• ☑ Prototype implementation path — Implement a runnable end-to-end prototype path for visual language system.
• ☑ Prototype validation and proof — Validate chart default behavior with concrete proof artifacts and repeatable steps.

context catalog nimble (Data AI Engineer Architect)

A runnable prototype path exists for context schema/catalog contracts and Nimble enrichment flows across product surfaces, with concrete artifacts that prove the flow works end-to-end in the current codebase. Core assumptions are documented, known constraints are explicit, and the team can explain what is real versus mocked without ambiguity.

• ☑ AI_CONTEXT core MCP tools built MCP Catalog and Agent Tools — Completed core MCP tool set (catalog, execute_query, render_dashboard, list_sources) for AI context consumption and act…
• ☑ AI_CONTEXT profiling layers 1-5 foundation built Profiling Foundation Layers 1-5 — Completed baseline profiling foundation (schema, enrichment, stats, samples, semantic/quality inference) used by AI_CON…
• ☑ AI_CONTEXT schema context formatter and MCP resources built MCP Catalog and Agent Tools — Completed token-efficient schema context formatter and MCP resources that expose pre-built AI context to agents.
• ☑ AI_CONTEXT table description ingestion built Profiling Foundation Layers 1-5 — Completed ingestion of database table descriptions into profiling output as baseline semantic enrichment.
• ☑ Prototype gaps and follow-on capture — Document top gaps and risks in cross-surface context contract that must be addressed next.
• ☑ Prototype implementation path — Implement a runnable end-to-end prototype path for context schema model.
• ☑ Prototype validation and proof — Validate context enrichment rules with concrete proof artifacts and repeatable steps.

dashboard factory (Data Analysis Evangelist and AI Training)

A runnable prototype path exists for repeatable process for producing, reviewing, and publishing quickstarts/examples, with concrete artifacts that prove the flow works end-to-end in the current codebase. Core assumptions are documented, known constraints are explicit, and the team can explain what is real versus mocked without ambiguity.

• ☑ Prototype gaps and follow-on capture — Document top gaps and risks in publication throughput operations that must be addressed next.
• ☑ Prototype implementation path — Implement a runnable end-to-end prototype path for template production pipeline.
• ☑ Prototype validation and proof — Validate quality rubric + review process with concrete proof artifacts and repeatable steps.

integrations platform (Head of Engineering)

A runnable prototype path exists for deployment, billing, 5T connectivity, and operational reliability/launch integration, with concrete artifacts that prove the flow works end-to-end in the current codebase. Core assumptions are documented, known constraints are explicit, and the team can explain what is real versus mocked without ambiguity.

• ☑ Prototype gaps and follow-on capture — Document top gaps and risks in reliability + launch operations that must be addressed next.
• ☑ Prototype implementation path — Implement a runnable end-to-end prototype path for platform deployment/integration path.
• ☑ Prototype validation and proof — Validate billing/connectivity operations with concrete proof artifacts and repeatable steps.