Start from a brief,
not a blank page

Build a CRM for a small sales team.

Core objects: Contact (name, company, email, phone, source, owner), Deal (title, contact, value, stage, expected close date), Activity (type: call/email/meeting/note, body, timestamp, linked contact or deal).

Screens:
1. Pipeline board — deals grouped by stage (Lead, Qualified, Proposal, Won, Lost), drag a card to change stage, each card shows title, value and days in stage.
2. Contact list — searchable and filterable by owner and source, click through to a detail page with the full activity timeline.
3. Today view — deals whose expected close date has passed and contacts with no activity in 14 days.

Seed the database with about 25 realistic sample contacts and 15 deals spread across stages so every screen has content on first load. Show deal value totals per stage in the board header.

Build a warehouse inventory management system.

Core objects: Product (SKU, name, category, storage location, unit, current stock, safety stock), Movement (type: inbound/outbound, product, quantity, reference number, operator, note, timestamp).

Screens:
1. Dashboard — total SKUs, total stock value, count of items below safety stock, and the ten most recent movements.
2. Inventory list — searchable by name/SKU/location, filterable by category and by status (normal, low, out of stock), with a status badge per row.
3. Movements — full ledger, filterable by inbound/outbound, showing the resulting balance after each entry.

Recording a movement must update the product's stock atomically and reject an outbound movement that would push stock below zero. Seed with roughly 30 products across several categories and 40 movements so the dashboard is populated.

Build an online storefront.

Core objects: Product (name, description, price, category, image placeholder, stock), CartItem (product, quantity), Order (items, total, customer name, email, shipping address, status, created date).

Screens:
1. Catalogue — responsive product grid, filter by category and price range, sort by price and by newest, with a search box.
2. Product detail — images, description, stock state, quantity selector, add to cart.
3. Cart — edit quantities, remove items, live subtotal.
4. Checkout — a simple form that creates an order, decrements stock, and shows a confirmation with the order number.
5. Orders — the customer's past orders with status.

The cart must survive a page reload. Seed with about 24 products across at least four categories.

Build an analytics dashboard for a SaaS product.

Data: a daily metrics table covering the last 180 days with columns for date, signups, active users, revenue, and churned users. Also a per-customer table with plan, monthly revenue, signup date and status.

Screens:
1. Overview — KPI cards for revenue, active users, signups and churn rate, each showing the change against the previous equivalent period; a date-range selector (7 / 30 / 90 days) that drives every card and chart.
2. Charts — a revenue-over-time line chart and a signups-vs-churn comparison chart. Render charts with a lightweight library or plain SVG; do not pull in a heavy dependency.
3. Customers — sortable, filterable, paginated table with plan and status filters.

Generate the seed data programmatically with a believable upward trend plus weekly seasonality, so the charts actually look like a real product.

Build a team task board.

Core objects: Task (title, description, status, assignee, priority, due date, labels, created date), Member (name, avatar initials, role).

Screens:
1. Board — columns for Backlog, In Progress, Review and Done; drag cards between columns; each card shows title, assignee initials, priority colour and due date, with overdue dates highlighted.
2. Filters — by assignee, priority and label, applied to the board without a reload.
3. My tasks — everything assigned to the current member, grouped into Overdue, Today, This week and Later.

Opening a card shows a detail panel where every field can be edited. Seed with 6 members and around 30 tasks spread across columns, priorities and due dates, including a few overdue ones.

Build a blog with a public site and an admin panel.

Core objects: Post (title, slug, excerpt, body as markdown, tags, cover colour, status: draft/published, published date, reading minutes), Tag.

Public side:
1. Home — featured post plus a paginated list of published posts.
2. Post page — rendered markdown, reading time, tags, and links to related posts.
3. Tag page — posts filtered by tag.
4. Search across titles and excerpts.

Admin side (at /admin):
5. Post list with status filter, and a create/edit form with a markdown editor and live preview.
6. Publishing toggles a post between draft and published; drafts must never appear on the public side.

Compute reading time from word count. Seed with about 12 posts across 5 tags, two of them drafts.

Build an appointment booking system for a small studio.

Core objects: Service (name, duration in minutes, price, description), Slot (date, start time, service, capacity), Booking (slot, customer name, email, phone, note, status: confirmed/cancelled, created date).

Screens:
1. Booking flow — pick a service, then a week view showing available slots with remaining capacity, then a details form, then a confirmation page with a reference code.
2. Manage — look up a booking by reference code and cancel it, which frees the capacity.
3. Admin — a day-by-day list of bookings with counts per service, and the ability to open or close slots.

Booking must be transactional: if a slot is full, the attempt fails cleanly with a clear message rather than overbooking. Seed with 5 services and four weeks of slots.

Build a quiz platform.

Core objects: Quiz (title, description, time limit, pass mark), Question (quiz, type: single-choice/multi-choice/true-false, text, options, correct answers, points, explanation), Attempt (quiz, taker name, answers, score, started and submitted timestamps).

Screens:
1. Quiz list — title, question count, time limit and best score if previously attempted.
2. Take a quiz — one question per page with a progress bar and countdown timer; answers autosave so a refresh does not lose progress; auto-submit when time runs out.
3. Result — total score, pass/fail against the pass mark, and a per-question breakdown showing the chosen answer, the correct answer and the explanation.
4. Editor — create and edit a quiz and its questions.

Grade multi-choice questions as all-or-nothing. Seed with 3 quizzes of 8 to 12 questions each.

Build an enterprise procurement and approval system for multiple departments.

Roles: Employee, Department Manager, Finance Approver, Procurement Officer and Administrator. Enforce permissions on the server, not only by hiding UI controls.

Core objects: Department and Cost Centre; Supplier; Purchase Request with line items, business justification, budget code, attachments, total and status; Approval Step with approver, decision, comment and timestamp; Supplier Quote; Purchase Order; immutable Audit Event.

Workflow: employees create drafts and submit them. Requests under $5,000 require the manager; $5,000–$25,000 require manager then Finance; above $25,000 also require Procurement and at least three supplier quotes. Rejection returns the request to the requester with a reason. Approved requests can be converted to a sequentially numbered purchase order exactly once. Prevent an approver from approving their own request.

Screens:
1. My requests and an inbox of approval tasks with SLA/overdue indicators.
2. Request detail showing line items, attachments, approval timeline and audit history.
3. Procurement workspace for comparing quotes side by side and issuing purchase orders.
4. Dashboard by department, category, supplier, cycle time and approval bottleneck.
5. Admin pages for approval thresholds, users, roles, departments and cost centres.

All workflow transitions must be transactional and validated server-side. Record actor, action, before/after state, timestamp and request correlation ID in the audit log. Seed 8 departments, 30 suppliers, 80 requests across every status, realistic approval histories and enough data to demonstrate access boundaries.

Build an enterprise IT service desk based on practical incident-management workflows.

Roles: Requester, Support Agent, Queue Manager and Administrator. Requesters can see only their own tickets; agents see tickets assigned to their permitted queues; managers can see and reassign all tickets in their queues. Enforce these rules server-side.

Core objects: User, Team, Queue, Service Catalogue Item, Ticket, Comment, Attachment, SLA Policy and immutable Activity Event. Tickets have a human-readable number, type (incident/service request), category, impact, urgency, derived priority, status, assignee, queue, requester, created/resolved timestamps and SLA deadlines.

Workflow: New → Triaged → In Progress → Waiting on Requester → Resolved → Closed, with Reopened supported. Priority is derived from an impact/urgency matrix. Pause response timers only in approved waiting states. Escalate breached tickets and notify the queue manager. Every assignment, status, priority and SLA change must be recorded.

Screens:
1. Employee portal with service catalogue, ticket submission and My requests.
2. Agent console with queue views, saved filters, bulk assignment and SLA countdowns.
3. Ticket workspace with conversation, internal notes, attachments, linked tickets and full activity timeline.
4. Operations dashboard for backlog, SLA compliance, mean time to resolution, reopen rate and volume by category.
5. Administration for queues, catalogue items, business hours and SLA policies.

Use transactional status changes and optimistic concurrency so two agents cannot silently overwrite each other. Seed 150 tickets over 90 days, including breached, escalated, reopened and waiting cases, plus 20 users and 4 support queues.

Build an enterprise employee lifecycle system covering onboarding, internal transfer and offboarding.

Roles: HR Partner, Hiring Manager, IT, Facilities, Task Owner, Auditor and Administrator. Apply field-level permissions: compensation and personal identifiers are visible only to authorised HR roles; auditors have read-only access.

Core objects: Employee, Department, Position, Lifecycle Case, Workflow Template, Task Template, Case Task, Equipment Assignment, System Access Request, Approval and immutable Audit Event. Tasks support dependencies, owner team, due-date offsets, completion evidence and escalation.

Workflow: HR starts a case from a versioned template. Tasks are generated with dates relative to start or termination date. A task unlocks only after its dependencies complete. Transfers require current and new manager approval. Offboarding cannot close until system access is revoked and assigned equipment is returned or formally excepted. Changes to dates must recalculate only incomplete task deadlines and preserve history.

Screens:
1. HR dashboard for upcoming starters/leavers, overdue work and cases at risk.
2. Case detail with employee summary, dependency timeline, approvals, tasks and audit history.
3. Team work queues for IT, Facilities and managers with bulk-safe actions.
4. Equipment and access register with ownership history.
5. Admin area for versioned workflow templates, roles, departments and escalation rules.

Protect sensitive fields in API responses as well as the UI. Make task completion and dependency unlocking transactional. Seed 60 employees and 25 lifecycle cases across onboarding, transfer and offboarding, including overdue and blocked examples.

Build an enterprise contract lifecycle management system.

Roles: Business Requester, Legal Reviewer, Finance Approver, Contract Owner and Administrator. Users may access contracts only for their legal entity or contracts explicitly shared with them; enforce this in every server query.

Core objects: Legal Entity, Counterparty, Contract, Contract Version, Review Task, Approval, Clause Issue, Obligation, Renewal Notice and immutable Audit Event. Contracts include type, owner, value, currency, effective/expiry dates, renewal terms, confidentiality level and lifecycle status.

Workflow: Draft → Legal Review → Finance Approval when value exceeds a configurable threshold → Signature Pending → Active → Expired/Terminated. Every uploaded revision creates a new immutable version; never overwrite prior files or metadata. Activating a contract creates its obligation schedule and renewal reminders. Prevent activation while mandatory reviews or unresolved high-risk clause issues remain.

Screens:
1. Contract repository with full-text metadata search, legal-entity and permission-aware filters.
2. Intake wizard with document upload, counterparties, dates, value and review routing.
3. Contract workspace showing version comparison metadata, review comments, approvals, obligations and audit history.
4. Calendar and work queue for renewals, expiries, obligations and overdue reviews.
5. Analytics for contract value, cycle time, renewal exposure and high-risk issues.
6. Administration for contract types, approval thresholds, clause-risk taxonomy and access policy.

Use transactions for workflow changes and unique constraints to prevent duplicate approvals and reminders. Seed 70 contracts across multiple entities and lifecycle states, with realistic versions, obligations, renewals and access restrictions.