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):
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