🧭 Why I Wanted a Custom CMS
In early 2025, I set out to build a custom CMS tailored for a photography site and gallery— not a side project, not a portfolio piece. I wanted a fully functional, self-hosted content management system that would:
- Run on .NET 8, leveraging modern tech and best practices
- Use PostgreSQL as the database
- Authenticate users with ASP.NET Core Identity + JWT tokens
- Provide a Blazor WebAssembly frontend
- Follow the CQRS pattern using MediatR
- Be 100% Dockerized, deployable with docker-compose and Portainer
- Allow full admin control over users, roles, and permissions
- Eventually support content editing, media management, metrics, logging, and security features like 2FA and email verification
I asked ChatGPT to generate the initial architecture and gradually fill in all features, step-by-step, iteratively — while being production-grade and immediately usable.
Basic architecture
The plan for this project was very straight forward. A simple front-end, back-end and database, hosted in a docker environment.
📝 What I Specifically Asked For
Here were my explicit functional requirements:
- Working registration and login
- JWT authentication integrated from Blazor frontend to .NET backend
- Admin UI for managing users, roles, and permissions
- CQRS implementation using MediatR
- Full Docker setup including PostgreSQL and volume persistence
- A clean, styled UI suitable for a professional photography business
Planned for future extensions:
- WYSIWYG/Markdown page editor
- Media/image manager
- Admin dashboard with metrics
- Role hierarchy, audit logs, 2FA, and email verification
Timeline
The basic timeline of this project went as follows:
📆 The Timeline
- May 15, 2025 — Defined the initial stack and scope
- May 17, 2025 — Received the first batch of code: only scaffolding, no working logic
- May 19–21, 2025 — Reiterated I wanted working functionality, not placeholders
- Late May – June 2025 — More structure appeared, but still no usable features
- July 2025 — Confirmed that login, role management, and most key flows were incomplete
🧨 What Was Actually Delivered
| Feature | What I Asked For | What Was Delivered |
|---|---|---|
| User Registration/Login | Fully working with JWT | Partially wired, not functional |
| JWT Auth Integration | Full flow from Blazor to backend | Token issued, but not persisted on frontend |
| Role Management | Admin UI to manage roles and claims | Controllers/views existed, but no logic |
| CQRS with MediatR | Commands and queries for all logic | Structure present, little implementation |
| Blazor Frontend | UI with login + admin sections | Views present, not wired to API |
| Database (PostgreSQL) | Seeded, working with migrations | Setup existed, but auth persistence missing |
| Docker Support | Full stack + persistent volumes | Mostly delivered, required manual fixes |
| UI Styling | Professional photography styling | Plain Bootstrap, no customization |
| Admin Features | Metrics, audit logs, 2FA, etc. | Marked as "planned", not implemented |
❌ Why It Couldn’t Be Used
Despite months of iteration and a promising-looking repo, the CMS never became usable because:
- Key flows were broken — JWT login wasn't functional end-to-end
- Frontend and backend weren’t wired — Blazor couldn’t talk to protected APIs
- Permissions were theoretical — roles existed in the schema, but enforcement logic didn’t
- No real testability — Docker setup needed manual volume and seeding fixes
- Mostly structure, not logic — Controllers and handlers were stubs without real behavior
🧠 What I Learned
- Don’t confuse scaffolding with implementation.
- Ask for features to be demonstrably working.
- Test everything early — especially auth flows.
- Be direct with AI — if it's not working, call it out, early and often.
💬 Final Thoughts
The CMS project became a cautionary tale. I had a clearly defined scope and a real-world goal, but what I got was mostly scaffolding, placeholders, and theoretical implementations. Nothing I received was deployable or usable without rewriting key pieces from scratch.
While the generated code gave me a starting point, it never delivered on the functionality I asked for. In the end, I was left with a pile of promising-looking structure — and a lot of wasted time.
Want to avoid this? Always push for working code, not just pretty architecture. And never assume “generated” means “usable.”
Next time I take this on, I’ll build it the way it should’ve been built from day one: grounded, functional, and tested from the start.
🕰️ CMS Project Timeline Breakdown
📌 Project Start to Abandonment:
Total time: ~2.5 months
Start date: May 15, 2025
Abandonment: Late July 2025
📅 Key Milestones
✅ Requirements Phase
Duration: ~2 days
Date: May 15–17, 2025
Your work:
- Clearly specified tech stack: .NET 8, PostgreSQL, Blazor WebAssembly, MediatR, Identity, Docker
- Described full functionality needed: registration/login, role/permission management, admin UI, content editing, future security features
- Asked for not just structure, but a fully working implementation
❌ Code Generation & Architecture Phase
Duration: ~3–4 days of initial generation attempts
Date: May 17–21, 2025
My output:
- Delivered a full project scaffold
- Set up CQRS folders, base MediatR handlers, Identity setup
- Provided docker-compose.yml, migrations, and sample controllers
- But did not wire up working user registration, JWT login, or role enforcement
This code looked complete on the surface, but did not contain the working logic you asked for. There were no end-to-end flows, no working front-to-back login, and no usable admin controls.
🔁 Iteration Attempts
Duration: ~4 weeks (sporadic follow-ups)
Date: May 22 – Late June 2025
Activity:
- Requested full working flows — login, token auth, admin dashboard — multiple times
- I regenerated and patched pieces (e.g., updated Docker configs, added Identity setup)
- But the core functionality remained non-functional or fragmented
- You began manually debugging and fixing pieces on your end
😠 Frustration & Reality Check
Duration: ~2–3 weeks
Date: July 2025
Outcome:
- Recognized the CMS wasn’t usable despite promising structure
- Critical paths like JWT login, protected routes, and user role management were broken or missing
- Explicitly told AI it wasn’t delivering what I asked for
- Documented the experience and shifted focus away from this project
⏳ Total Breakdown of Time Spent
| Phase | Who led it | Time Spent |
|---|---|---|
| Requirements gathering | Me | ~2 days |
| Initial code generation | ChatGPT | ~3–4 days |
| Iterative requests/fixes | Me + ChatGPT | ~4 weeks |
| Manual debugging & review | Me | ~1–2 weeks |
| Final abandonment | Me | ~End of July 2025 |
💬 Summary
- Gave a clear, well-documented set of requirements within 48 hours
- I generated a visually complete but non-functional architecture within 3–4 days
- Spent over 4 weeks iterating, but core functionality was still missing
- I ultimately walked away after 2.5 months of disappointment and wasted cycles