I Rebuilt My Abandoned Dashboard by Starting With Docs — Kumachi Back Office

Ernest Serunkuma — Mon, 08 Jun 2026 04:20:02 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge.

What I Built

Kumachi Back Office is the private operating system for my creative and professional world. It is a founder command center — not a CRM, not a task manager, not an analytics dashboard — but a cockpit that pulls everything together.

It manages four public cores of Kumachi:

eSerunkuma — my personal brand, consulting, writing, and authority layer
Kumachi Studio — my agency: client services, websites, automation, marketing
Kumachi Prints — my art commerce core: prints, products, digital downloads
Kumachi Gallery — my cultural core: stories, events, tours, experiences

Every morning, it answers the questions I actually need answered:

What should I do today?
Where is money closest right now?
Which core needs attention?
Which lead needs follow-up?
What should I publish, finish, or sell next?

The dashboard is built on Next.js 16, Supabase (Postgres + Auth + RLS), TypeScript, Tailwind CSS, and shadcn/ui — deployed on Vercel. It is the first working release of what will eventually become a fully automated, AI-powered agency operating system.

Demo

Before (abandoned first version):

Repo: github.com/kumachistudio/kumachi-dashboard
Video: youtu.be/BO54kmJxDU4

After (this submission):

Live: kumachi-back-office.vercel.app — use demo@kumachi.test / demopass123
Video: youtu.be/JTWnwCFtdBM
GitHub: github.com/serunkuma/kumachi-dashboard-polished

The Comeback Story

This project began during my thinking around the earlier Notion MCP Challenge. That challenge made me think deeply about AI-powered workflows and what it could mean for a solo founder to have systems that help them think, act, and follow through.

My first version of Kumachi Dashboard tried to do everything at once:

Marketing analytics
Social listening
Campaign integrations
Report generation
Scraping workflows
An Eisenhower-style command board
AI briefing system

The idea was strong. The system was not. It had a Flask backend, a Next.js frontend, and a roadmap that kept expanding. It became more of a map of everything I wanted than a tool I could actually use. Eventually I stopped.

A few months later I came across something that reframed how I was thinking about building tools for myself.

Ubuntu Engineering wrote about documentation-driven development — the practice of writing what you are building before you write code. Not just a README. A real product definition: the purpose, the users, the data model, the architecture, the boundaries, what it explicitly is not. The document becomes the authority. Code follows the document.

GitHub has been building tooling around the same principle with spec-kit — the idea that specifications written before implementation produce better software than specifications reverse-engineered from it.

The insight for me was this: I had been building before I knew what I was building. Every session started with code and ended with more questions than answers. Documentation-driven development reverses that order.

I restarted Kumachi Dashboard using this approach.

Before touching the editor, I spent two days writing. I captured:

What Kumachi is, and what it explicitly is not
The four business cores it serves and their revenue models
The operating loop: Plan → Publish → Attract → Capture → Sell → Deliver → Learn → Repeat
The data entities and their relationships
The tech architecture and why
The integration roadmap
The lessons from the abandoned first version
The dream map — where this eventually goes

These source documents live in /sources in the repo — frozen, never edited, only referenced. Then I transformed them into structured docs in /docs. Only then did I write code.

Before:

Split Flask + Next.js setup
Broad marketing analytics scope
Many unfinished integrations
Unclear daily workflow
Project felt impossible to finish

After:

Next.js 16 App Router
Supabase Auth, Postgres, and RLS
Founder-first protected dashboard
Today page with tasks and daily review
Four Core Dashboard
Revenue Center
Leads CRM
Offers and Tasks flows
Placeholder pages for future modules
Docs-driven roadmap for what comes next

The most meaningful part is that the new app is closer to how I actually work. Kumachi is not just a software idea. It is connected to my writing, art, services, products, cultural work, and the long-term thing I am trying to build.

My Experience with GitHub Copilot

The most useful thing GitHub Copilot did was not write code. It was reasoning with context.

Because I had source documents, every session started from a shared understanding. I could say: "Given the four-core architecture in AGENTS.md and the lead entity definition in the data schema, generate the server action for creating a new lead." Copilot had something to work from. The output matched the product vision instead of drifting from it.

The old version taught me that building without documentation is building a ship in a bottle — impressive from the outside, impossible to maintain from within. With the docs in place, Copilot became a genuine implementation partner rather than a code-completion tool.

The process looked like this:

Capture messy ideas and lessons from the old project
Turn them into clean source documents
Transform those sources into structured docs (concepts, schema, system design, planning phases)
Generate the MVP implementation with Copilot, grounded in the docs
Review the scaffold against the docs — what matched, what was missing
Iterate: fix routes, validation, build errors, seed data, middleware
Prepare the project for a public before/after submission

At every step, the documents were the authority. Code had to match them.

Copilot also helped me ask better questions during the product definition phase:

Is this a public website or a private back office?
Is this a trading dashboard? No.
Is this a generic CRM? No.
What is the smallest thing that would actually help me tomorrow morning?
What should stay future-only? What needs to be real now?

That changed the project. The old version was a dream map. The new version is the beginning of an operating system.

The Plane I Keep Building

Kumachi Back Office is not a project I will finish and move on from.

It is the plane I fly while I build it. Every week I run the agency, I find something the dashboard could do better. A client health flag I missed. A proposal that should have drafted itself. A piece of content that went unpublished because I forgot to schedule it.

The documentation-driven approach means I know exactly where those improvements go — in a phase document, in the roadmap, in the backlog. Nothing gets lost. Nothing inflates the current sprint.

The public version of this repo is the open-source foundation — the blueprints for what I am building. The full system I am advancing privately includes:

Market intelligence: competitor ad monitoring, daily AI briefings, industry trend tracking
Inbound engine: SEO gap detection, automated content briefs, lead scoring
AI command brain: natural language queries over live data, voice-to-task, morning priority briefings
Ads war room: campaign anomaly alerts, budget reallocation AI, auto client reports
Social listening: brand mentions, sentiment tracking, competitor conversation monitoring

The nine zones of the God Dashboard — what I call the full vision — are documented in docs/research/northstar-dream-map.md in this repo if you want to see where this is going.

The foundation is solid. The direction is documented. The plane is flying.

What's Planned Next

Short term (next 4 weeks):

Complete the revenue proposal and deal flow
Richer seeded demo data for public use
Stronger first-user onboarding

Medium term (next 3 months):

Notion sync for daily review notes and strategy documents
n8n automation flows for lead capture and content scheduling
Team capacity and task assignment views

Long term (the God Dashboard):

Full market intelligence layer with competitor monitoring and daily AI briefings
AI command brain: talk to your agency data in natural language
Inbound engine: content and SEO automation that generates leads without outreach

Repository: github.com/serunkuma/kumachi-dashboard-polished
Before app: github.com/kumachistudio/kumachi-dashboard