← Back to selected work
SuccessKPI internship projectHanded off for further development

Greyline

Internal BI for discovery, demos, and dashboards.

An internal business intelligence application connecting requirements from discovery and demo conversations with demo preparation, datasets, KPI calculations, and dashboard creation and presentation in one workspace.

My role
Architecture, interface design, analytical logic, implementation, validation, and handoff
Built with
Browser application, Python MCP tools, structured project artifacts
Inside the project
Greyline’s Metrics Sheet showing a synthetic support-operations project and the exact first-contact-resolution formula, dependencies, and build notes.
Actual application: the metric catalog and an inspected first-contact-resolution definition from a synthetic portfolio build.View full size

The Metrics Sheet and planner screenshots show a fresh, entirely synthetic support-operations demonstration generated in Greyline’s deterministic mode. The validation screen is a saved synthetic QA build. No customer discovery records are included.

Why I built it

A useful analytics demo starts well before the dashboard. The discovery questions, dataset, metric definitions, visualization choices, and implementation instructions all need to agree.

I built Greyline during my solutions-consulting internship to connect more of that workflow in one application. It brought the business question, data, analytical logic, and presentation together, with reusable guidance another person could understand and carry forward.

My part in the work

I owned the architecture, interface, analytical logic, implementation, testing, iteration, and handoff. I used Claude Code and Codex to help carry the work across coding, interface design, and validation while staying responsible for the technical decisions and results. I also built a Python MCP server with nine tools for dataset profiling, formula validation, source-based claim verification, and dashboard guidance. I handed off the application and supporting materials for further development and implementation.

How the pieces connect

  1. Start with discovery

    Bring requirements from discovery and demo conversations into a shared project: the audience, business question, data needs, and dashboard story.

  2. Connect data and calculations

    Prepare demo datasets, metric definitions, KPI formulas, and supporting guidance in synchronized project artifacts.

  3. Create the presentation

    Arrange the dashboard structure, reusable HTML presentation components, and native visualization definitions in the application.

  4. Validate and deliver

    Check data and analytical logic, carry the presentation into the target analytics platform, and document the native objects the consultant still needs to construct.

Inside the work

Actual screens, with the reasoning beside them

Keep the page plan connected to the objects.

The Dashboard Planner opens with the active project’s HTML components and native visualization plan already arranged. In this synthetic example, eight planned tiles make the page structure visible before the final dashboard is assembled.

The distinction between HTML presentation elements and native analytics visuals matters: the blueprint tells the builder what each object is, instead of treating the whole dashboard as an opaque picture.

Greyline Banner Builder showing a generated one-page dashboard plan with eight labeled HTML and native visualization tiles.
A real generated plan from the synthetic portfolio example, with separate labels for HTML components and native visualizations.View full size

Make implementation traps part of the handoff.

The preparation checklist carries forward practical issues such as import types, joins, metric scales, and the formula syntax expected by the analytics platform.

The metric view goes further: its first-contact-resolution definition includes the exact formula, dependencies, build order, and a warning about comparing a text attribute to a quoted value. That detail helps another person reproduce the intended calculation.

Greyline’s saved Offline QA Build showing its pre-flight checks for dataset preparation, formula syntax, and metric scales.
Saved release evidence from the synthetic Offline QA Build: checks travel with the project rather than living in a separate conversation.View full size

What the demonstration actually produced

The synthetic portfolio run generated a 450-row interaction dataset, one chapter, five metric/object definitions, three native visualization definitions, and five HTML components. These counts describe this example, not a product limit or customer deployment.

Dataset
450 synthetic interaction rows
Metric example
First-contact resolution, with numerator, denominator, dependencies, and exact formula
Page plan
Five HTML components plus three native visualization tiles

Decisions that shape the project

One project owns the artifacts

Datasets, the Blueprint, Metrics Sheet, Viz Assembly, HTML Kit, and planner all refer to the same build context.

Keep local generation honest

The standalone workflow uses a deterministic browser engine. Optional provider adapters are separate; a local result is not presented as a cloud-model response.

Design for the next builder

Copyable formulas, explicit dependencies, visual plans, and validation guidance make the handoff part of the product.

Where it stands

The application was handed off for further development and implementation. The screenshots document its metric catalog, dashboard planning, presentation components, and validation workflow. Native analytics objects in the target MicroStrategy platform still required manual construction. The screens show the Grey Line release; later project materials use the name DTD, or Data to Dashboard.

What comes next

Continue improving the generation, verification, and handoff workflow while keeping the dataset, metrics, and page plan consistent.