Problem / Motivation
Building and maintaining Board data models, rules and capsules is becoming increasingly complex.
While Board offers powerful modeling capabilities, development is still mostly manual and UI-driven.
At the same time, modern software development is evolving rapidly:
- Requirements, architecture and code are increasingly created with AI support
- Teams work with agent-based workflows (Product Owner, Architect, Developers, Testers)
- Git repositories act as the single source of truth
- Automated tests protect systems against regressions and upgrades
Today, Board solutions cannot fully benefit from these approaches.
Core Idea
Enable AI-driven development of Board applications, where:
- Board metadata is treated as Model-as-Code
- A Git repository is the single source of truth
- Board ALM manages the lifecycle between Git and Board environments
- AI agents collaborate to design, implement and test data models and capsules
1) AI Agent-Based Development Model
Instead of manually creating everything in the Board UI, development starts in a Git repository.
An AGENTS.md file defines the AI agents involved, for example:
- Product Owner Agent
Translates business goals into user stories and acceptance criteria - Solution Architect Agent
Defines data model structure, calculation concepts and design decisions (ADRs) - Backend Developer Agent
Implements data models and calculation rules as metadata JSON - Backend Tester Agent
Creates test datasets and automated tests for calculations - Frontend Developer Agent
Designs capsules, layout and navigation as metadata - Frontend Tester Agent
Validates capsule structure and basic UI behavior
Each agent works on clearly defined artifacts in the repository.
2) AI-Generated Artifacts (Concrete Example)
With AI support, a typical flow could look like this:
- Product Owner Agent
- Creates user stories and business rules (Markdown)
- Solution Architect Agent
- Defines the target data model
- Documents architectural decisions (ADR)
- Developer Agents
- Generate Board metadata as JSON strictly validated against versioned JSON Schemas:
- Databases, dimensions, cubes
- Calculation rules
- Capsules (pages, layout, navigation)
- Tester Agents
- Generate test cases:
- Input data
- Expected calculation results
All artifacts are versioned and reviewable in Git.
3) Git-First + ALM Lifecycle
The Git repository is the single source of truth.
Git → Board
- ALM deploys AI-generated or manually edited metadata into DEV / TEST / PROD
- Changes are transparent and reproducible
Board → Git (Explicit Publish / Promote)
- Manual UI changes are allowed in DEV
- Changes are committed back to Git only after an explicit publish/promote step
- This ensures clean versioning and governance
4) Automated Testing as a First-Class Citizen
AI agents can also generate and maintain tests:
- Runtime regression tests can be executed in Board by running a Procedure that materializes results via “Extract all Cubes” (CSV export) and comparing the exported CSV snapshots against expected baselines in CI.
- Test execution after:
- Metadata changes
- Board upgrades
- Test Layers
- Schema validation (fast): every generated/edited JSON must validate against the repo’s schemas
- Lint / best-practice checks (custom): naming, forbidden patterns, performance heuristics
- Runtime tests: golden datasets + expected calculation results in Board/CI environment
Tests become part of the standard ALM pipeline, increasing trust in the solution.
5) Why This Is More Than “Just Automation”
This approach enables:
- Faster solution design through AI assistance
- Higher quality through systematic testing
- Knowledge preservation (design decisions don’t live only in people’s heads)
- Safer upgrades and refactoring
- Reusable and composable Board solution components
Suggested MVP
- JSON-based metadata export/import + versioned JSON Schemas for:
- Data models & rules
- Capsules (layout & navigation)
- CI pipeline: schema validation + custom rule checks on every PR
- ALM Git integration (pull/deploy + commit on publish)
- Git-first governance model
- Basic automated calculation tests (e.g., golden datasets + Procedure-based CSV snapshots via “Extract all Cubes”)
- Reference AI agent workflow (documentation & examples)
Long-Term Vision
Board could evolve from a UI-centric modeling tool into a platform that supports:
- AI-assisted application design
- Professional DevOps practices
- Scalable enterprise solution development
This would make Board even more attractive for both business users and modern data / software engineering teams.
Design Considerations
- Stable, deterministic metadata representation
- Clear agent responsibilities
- Guardrails for AI-generated models (naming, performance, best practices)
- Schema-first guardrails
- JSON Schema as contract: schemas define required fields, enums, naming patterns and versioning for every artifact type (model, rules, capsules).
- Repo as single source of truth: schema changes are reviewed like code (PRs), enabling safe evolution of the metadata format.
- Custom validators for cross-file constraints: referential integrity (IDs, links) and domain rules run in CI in addition to schema validation.
- Clear conflict resolution between Git and UI changes
This approach does not replace the Board UI – it complements it with AI-driven, version-controlled and testable development workflows.
