forked from Qortal/q-blog
greenflame089
6.6 KiB
6.6 KiB
TL;DR: Here’s a non-technical, stepwise roadmap from today’s v0.0.0 to a polished 1.0.0. It front-loads docs + testing, cleans correctness/a11y/UX, then adds multi-blog per name, and finally shared blogs. Each phase has clear outcomes and “done” checks.
Q-Blog → 1.0.0 Roadmap (non-technical)
Phase 0 — Orientation & Quality Bar (now)
Goal: Align on what “top quality” means.
- Define success metrics: a11y baseline, crash/error rate, perf feel (snappy interactions), test coverage targets, doc set.
- Pick a short list of user journeys to protect (e.g., read posts, create post, edit post, manage blogs). Done when:
- We have a one-pager of goals/metrics and the protected journeys list.
Phase 1 — Project Docs & Working Agreements
Goal: Make the project legible and predictable.
- Author concise docs (what/why/how): Overview, Architecture sketch, Testing approach, Accessibility expectations, Contributing, Changelog.
- Record a few early decisions (editor, state, data shapes) as short decision notes. Done when:
- New contributor can read docs and understand how to run, test, and contribute—without asking questions.
Phase 2 — Test Harness & Linting Baseline (no feature work yet)
Goal: Establish guardrails to catch regressions early.
- Stand up unit/component test harness and a minimal test pyramid strategy (unit > component > a few integration).
- Add accessibility and code-quality lint passes (no rules list yet—just the intent). Done when:
- “Run tests” and “lint” are routine and green on a clean checkout.
- We can write a simple render test for a page without friction (proof the harness works).
Phase 3 — Correctness Sweep (stability before polish)
Goal: Remove known hazards and obvious defects.
- Replace legacy/broken imports, remove blanket type-ignores, fix crashing edge cases and flaky flows.
- Normalize basic data flows (loading/error/empty states) so the app never “mystery fails.” Done when:
- No known red flags remain (e.g., invalid imports, suppressed type errors, missing alt text).
- Core pages load and operate consistently on a fresh profile.
Phase 4 — Accessibility Baseline (foundational)
Goal: Make the app operable by keyboard and assistive tech.
- Landmarks & navigation: header/nav/main/footer + skip link.
- Focus management for dialogs/menus/editor; visible focus rings.
- Text alternatives, form labels, live region for async work; motion/contrast preferences respected. Done when:
- Keyboard-only journeys succeed; basic automated checks are clean; a short manual checklist passes.
Phase 5 — UX & Information Architecture Touch-up
Goal: Reduce friction and ambiguity before adding new power.
- Clear page hierarchy and navigation; consistent button labels and empty/error states.
- Editor ergonomics: predictable toolbar states, undo/redo clarity, draft/publish feedback. Done when:
- The protected journeys feel obvious and forgiving (you can’t get stuck; errors are actionable).
Phase 6 — Data Model Extension: Multiple Blogs per Name
Goal: Allow one “name” to own several separate blogs.
- Concepts (non-technical): Name owns 0..N Blogs; Post belongs to exactly one Blog.
- Identity: pick a human-friendly blog identifier (e.g., “name + blog handle”) that works well in URLs.
- UX: a simple “Blog switcher” and “Create new blog” flow; list scoped to current blog.
- Migration: existing content becomes Blog #1 for each name. Done when:
- A user can create/switch blogs and see posts scoped appropriately.
- Existing users’ posts are intact under their first blog without surprises.
Phase 7 — Permissions Model: Shared Blogs
Goal: Enable collaboration on a blog.
- Roles (simple first): Owner, Editor, Author (can post), Viewer (implicit, public).
- Invitations & membership management: add/remove collaborators; show who has access.
- Edit safeguards: clear attribution on posts, activity notes on updates (lightweight). Done when:
- Owner can invite/remove collaborators.
- Collaborators can create/edit posts according to role, and non-members cannot.
Phase 8 — Performance & Resilience
Goal: Keep interactions fast and reliable as features grow.
- Perceived speed: snappy navigation, optimistic updates where safe, progress indicators for async operations.
- Robustness: graceful offline/slow-network handling for key actions; safe retries on saves/uploads. Done when:
- Core actions “feel instant” with clear feedback, and temporary failures recover without data loss.
Phase 9 — Internationalization & Theming Consistency (light)
Goal: Make UI text and visuals consistent and adaptable.
- Externalize UI strings; ensure headings/labels follow a consistent style.
- Validate light/dark themes for contrast and motion preferences. Done when:
- Strings are centralized for future i18n; themes meet contrast/motion guardrails.
Phase 10 — Observability, Security & Release Readiness
Goal: Ship 1.0 with confidence.
- Error boundaries and user-friendly error pages; minimal analytics/telemetry (opt-in) to catch crashes.
- Basic security posture review (inputs, uploads, permission checks).
- Backups/migration notes; upgrade guide; crisp release notes. Done when:
- We can trace and act on production errors; permissions are enforced in all write paths; the “1.0 checklist” is fully checked.
Why this order?
- Docs + tests first reduce rework (catch issues as we fix).
- Correctness → a11y → UX ensures polish builds on stable, inclusive foundations.
- Multi-blog precedes Shared blogs so collaboration lands on the right data model.
- Perf/Resilience and Release bookend features to keep the app trustworthy.
Acceptance bars (numbers keep us honest)
- Accessibility: keyboard-only passes for protected journeys; automated checks free of critical issues.
- Reliability: zero known crashers in core flows; error states always show recovery actions.
- Testability: green test/lint on clean checkout; steadily rising coverage (we’ll agree targets when we stand up the harness).
- Usability: no dead ends; consistent labels; empty/error states always informative.
On your two feature asks
- Multiple blogs per name: 👍 Fits naturally with Q-Blog’s goals and unlocks better organization. We’ll keep identifiers human-readable and migrate existing content seamlessly.
- Shared blogs: 👍 A strong, later-phase addition. We’ll start with a lean role model and keep invites/management simple to avoid UX sprawl.