30 Replit Agent Prompts to Build Web Apps (2026)

Build a personal task manager web app. Who it's for: individuals who want a clean daily to-do list that persists across devices. Core flows: sign in with Replit Auth → add a task → set due date and priority → mark complete → filter by Today / Upcoming / Done. Data model: Users (from Replit Auth); Tasks (id, user_id, title, notes, due_date, priority [low/med/high], status [open/done], created_at). Stack: use Replit Auth for login and Replit Database (Postgres) for storage; you choose the frontend framework. Design: clean, modern, mobile-responsive, light and dark mode. Scope for this pass: only the above — every user sees only their own tasks. Out of scope: sharing, recurring tasks, reminders, teams. Test the full add → complete → filter flow yourself before finishing.

Build a note-taking web app. Who it's for: people who want a fast personal notebook with search. Core flows: sign in with Replit Auth → create a note with a title and rich-text body → auto-save on edit → organize with tags → search notes by keyword. Data model: Users; Notes (id, user_id, title, body, updated_at); Tags (id, user_id, name); NoteTags (note_id, tag_id). Stack: Replit Auth + Replit Database (Postgres). Design: distraction-free two-pane layout (list + editor), mobile-responsive, dark mode. Scope: notes CRUD, tagging, and search only, scoped per user. Out of scope: sharing, folders, file attachments, offline mode. Run this in Plan Mode first and show me the plan before building.

Build a habit tracker web app. Who it's for: individuals building daily habits who want streaks and a calendar view. Core flows: sign in with Replit Auth → create a habit (name, target frequency) → check it off each day → see the current streak and a month calendar heatmap. Data model: Users; Habits (id, user_id, name, frequency [daily/weekly], color, created_at); Checkins (id, habit_id, date, done). Stack: Replit Auth + Replit Database (Postgres). Design: colorful, motivating, mobile-first; a per-habit streak counter and a GitHub-style heatmap. Scope: create habits, daily check-ins, streaks, and the heatmap, per user. Out of scope: reminders/notifications, social features, analytics dashboards. Test that checking off a habit updates both the streak and the heatmap.

Build a personal expense tracker web app. Who it's for: someone tracking spending against a monthly budget. Core flows: sign in with Replit Auth → add an expense (amount, category, date, note) → set a monthly budget per category → see a dashboard of spend by category vs budget for the selected month. Data model: Users; Expenses (id, user_id, amount, currency, category, spent_on, note); Budgets (id, user_id, category, month, limit_amount). Stack: Replit Auth + Replit Database (Postgres). Design: clean dashboard with a category bar chart and a spend-vs-budget summary; mobile-responsive. Scope: expense CRUD, per-category monthly budgets, and the dashboard, per user. Out of scope: bank imports, receipts/OCR, multi-currency conversion, recurring bills. Show the plan in Plan Mode first.

Build a personal recipe box web app. Who it's for: home cooks who want to save and find their recipes. Core flows: sign in with Replit Auth → add a recipe (title, ingredients list, steps, tags, photo URL, servings) → browse a card grid → search by title or ingredient → open a recipe detail view. Data model: Users; Recipes (id, user_id, title, ingredients [text/list], steps, servings, image_url, created_at); Tags and RecipeTags. Stack: Replit Auth + Replit Database (Postgres). Design: warm, appetizing card grid with a clean recipe detail page; mobile-responsive. Scope: recipe CRUD, tags, and search, per user. Out of scope: meal planning, shopping lists, public sharing, image uploads (use a URL field for now). Test add → search-by-ingredient → open detail.

Build a reading list and bookmark manager web app. Who it's for: people who save links to read later. Core flows: sign in with Replit Auth → paste a URL and save it (auto-fetch the page title if easy, else let me type it) → tag it and mark read/unread → filter by tag and status → search. Data model: Users; Bookmarks (id, user_id, url, title, note, is_read, created_at); Tags and BookmarkTags. Stack: Replit Auth + Replit Database (Postgres). Design: clean list with favicon, title, and tag chips; mobile-responsive; dark mode. Scope: save/tag/mark-read/filter/search, per user. Out of scope: browser extension, full-text article capture, sharing. Test saving a link, tagging it, and filtering to unread.

Build a link-in-bio app. Who it's for: creators who want one public page of links, editable from a private dashboard. Core flows: sign in with Replit Auth → edit my profile (display name, bio, avatar URL, theme color) → add/reorder/remove links (label + URL) → my public page lives at /u/[username] and shows the links; visitors don't need to log in. Data model: Users (username, display_name, bio, avatar_url, theme); Links (id, user_id, label, url, position). Stack: Replit Auth for the owner dashboard, Replit Database (Postgres) for storage; the public page is read-only and unauthenticated. Design: modern mobile-first public page (like a Linktree), clean editor dashboard. Scope: editable profile, ordered links, public page. Out of scope: analytics/click tracking, custom domains, payments. Test that edits in the dashboard appear on the public /u/[username] page.

Build a lightweight CRM web app. Who it's for: a small sales team tracking deals through a pipeline. Core flows: sign in with Replit Auth → add a contact and a company → create a deal linked to a contact → drag the deal across pipeline stages (Lead → Qualified → Proposal → Won/Lost) → log a note/activity on a deal → see a pipeline board and a simple totals summary. Data model: Users; Companies (id, name, website); Contacts (id, company_id, name, email, phone, owner_id); Deals (id, contact_id, title, value, stage, owner_id, created_at); Activities (id, deal_id, user_id, type, note, created_at). Stack: Replit Auth + Replit Database (Postgres). Design: clean kanban pipeline board plus contact/company detail pages; mobile-responsive. Scope: contacts, companies, deals with a drag-and-drop pipeline, and activity notes. Out of scope: email integration, reporting dashboards, permissions/roles, import. Run in Plan Mode and show the plan first.

Build an invoicing web app for freelancers. Who it's for: solo freelancers who bill clients. Core flows: sign in with Replit Auth → add a client → create an invoice with line items (description, qty, unit price) → the app computes subtotal, tax, and total → set status (Draft/Sent/Paid) → view an invoice as a clean printable page and export/print to PDF. Data model: Users; Clients (id, user_id, name, email, address); Invoices (id, user_id, client_id, number, issue_date, due_date, status, tax_rate); LineItems (id, invoice_id, description, quantity, unit_price). Stack: Replit Auth + Replit Database (Postgres). Design: professional invoice layout with my business details in settings; mobile-responsive. Scope: clients, invoices with line items and totals, statuses, and a printable view. Out of scope: online payments, recurring invoices, multi-currency, email sending. Test creating a two-line invoice and confirm the total math is correct.

Build a team project board web app. Who it's for: small teams managing work across projects. Core flows: sign in with Replit Auth → create a project → invite/assign teammates → add tasks with status, assignee, and due date → move tasks across columns (To Do / In Progress / Done) on a kanban board → see a per-project board. Data model: Users; Projects (id, name, owner_id); ProjectMembers (project_id, user_id, role [owner/member]); Tasks (id, project_id, title, description, status, assignee_id, due_date, created_at). Stack: Replit Auth + Replit Database (Postgres). Design: clean kanban with drag-and-drop and an assignee avatar on each card; mobile-responsive. Scope: projects, membership, tasks, and a drag-and-drop board; members only see projects they belong to. Out of scope: comments, file attachments, notifications, time tracking. Run in Plan Mode first, then build and test the create-project → add-task → move-task flow.

Build a team wiki / internal knowledge base web app. Who it's for: a team that wants a searchable set of docs. Core flows: sign in with Replit Auth → create a page with a title and rich-text/markdown body → organize pages into spaces/categories → edit pages (keep a simple last-edited timestamp and editor name) → full-text search across pages. Data model: Users; Spaces (id, name); Pages (id, space_id, title, body_markdown, updated_at, updated_by); optional PageRevisions later. Stack: Replit Auth + Replit Database (Postgres). Design: left sidebar of spaces/pages, clean readable article view, markdown editor; mobile-responsive. Scope: spaces, pages CRUD, markdown rendering, and search; any signed-in team member can read and edit. Out of scope: granular permissions, version history diffing, comments, page nesting beyond one level. Test create page → edit → search finds it.

Build a support ticket / help desk web app. Who it's for: a small support team handling customer requests. Core flows: sign in with Replit Auth → a customer (or agent on their behalf) submits a ticket (subject, description, priority) → agents view a queue, filter by status/priority, assign a ticket to themselves → add replies/internal notes on a ticket → change status (Open → In Progress → Resolved → Closed). Data model: Users (role: agent/customer); Tickets (id, customer_id, subject, description, priority, status, assignee_id, created_at); Messages (id, ticket_id, author_id, body, is_internal, created_at). Stack: Replit Auth + Replit Database (Postgres). Design: agent inbox/queue view plus a ticket detail thread; mobile-responsive. Scope: submit, queue, assign, reply, status changes, with an internal-note flag. Out of scope: email ingestion, SLAs, canned responses, reporting. Run in Plan Mode first.

Build an applicant tracking web app. Who it's for: a hiring manager tracking candidates for open roles. Core flows: sign in with Replit Auth → create a job opening → add candidates to an opening (name, email, resume URL, source) → move candidates across stages (Applied → Screen → Interview → Offer → Hired/Rejected) on a board → leave notes and a rating on a candidate. Data model: Users; Jobs (id, title, department, status); Candidates (id, job_id, name, email, resume_url, source, stage, rating, created_at); Notes (id, candidate_id, author_id, body, created_at). Stack: Replit Auth + Replit Database (Postgres). Design: per-job kanban pipeline with candidate cards; clean candidate detail page; mobile-responsive. Scope: jobs, candidates, stage pipeline, notes, and ratings. Out of scope: resume parsing, email, scheduling, scorecards, multi-team permissions. Test moving a candidate across stages and adding a note.

Build a client portal web app for an agency. Who it's for: an agency and its clients, each seeing only their own project. Core flows: sign in with Replit Auth → an admin creates a client project and adds updates, files (as URLs), and milestones → the client logs in and sees only their project's updates, files, and milestone status → clients can leave a comment on an update. Data model: Users (role: admin/client, client_id for client users); Projects (id, client_name, status); Updates (id, project_id, title, body, posted_at); Files (id, project_id, label, url); Milestones (id, project_id, name, due_date, done); Comments (id, update_id, author_id, body). Stack: Replit Auth + Replit Database (Postgres). Design: clean client-facing dashboard and a simple admin view; mobile-responsive. Scope: admin posts, client-scoped read access, comments. Out of scope: billing, file uploads, notifications, multiple projects per client. Enforce that a client can only ever see their own project — test with two client accounts. Run in Plan Mode first.

Build a time tracking web app. Who it's for: consultants and small teams logging billable hours per project. Core flows: sign in with Replit Auth → create projects → start/stop a timer or add a manual time entry (project, description, start, end/duration) → see entries grouped by day and by project → see weekly totals per project. Data model: Users; Projects (id, name, client, rate_per_hour); TimeEntries (id, user_id, project_id, description, started_at, ended_at, duration_minutes). Stack: Replit Auth + Replit Database (Postgres). Design: clean timer widget plus a weekly timesheet table with totals; mobile-responsive. Scope: projects, timer + manual entries, and weekly/project totals, per user. Out of scope: invoicing, approvals, team reporting, integrations. Test that starting and stopping the timer creates an entry with the correct duration.

Build an appointment booking web app (Calendly-style). Who it's for: a solo service provider taking bookings. Core flows: provider signs in with Replit Auth → sets weekly availability (days + time ranges) and appointment length → a public booking page shows open slots for the next 2 weeks → a visitor picks a slot and enters name/email to book (no login required for visitors) → provider sees all upcoming bookings and can cancel one. Data model: Users (provider); Availability (id, provider_id, weekday, start_time, end_time, slot_minutes); Bookings (id, provider_id, name, email, start_at, end_at, status). Stack: Replit Auth for the provider dashboard, Replit Database (Postgres) for storage; public booking page is unauthenticated. Design: clean calendar/slot picker; mobile-first. Scope: availability, generated open slots, public booking, and provider list/cancel. Critical rule: never allow two bookings in the same slot — check for conflicts before confirming. Out of scope: payments, reminders, multiple providers, timezones beyond the provider's. Run in Plan Mode first and test that a double-book is rejected.

Build an event RSVP web app. Who it's for: hosts running events with a guest cap. Core flows: host signs in with Replit Auth → creates an event (title, description, date/time, location, capacity) → gets a public event page at /e/[id] → guests RSVP (yes/no/maybe + name/email, no login) → the page shows spots remaining and closes RSVPs when full → host sees the guest list. Data model: Users (host); Events (id, host_id, title, description, starts_at, location, capacity); Rsvps (id, event_id, name, email, response, created_at). Stack: Replit Auth for the host, Replit Database (Postgres); public RSVP page is unauthenticated. Design: attractive public event page with a clear RSVP form and remaining-spots counter; mobile-first. Scope: create event, public RSVP with capacity enforcement, host guest list. Rule: don't accept a "yes" RSVP once capacity is reached. Out of scope: ticketing/payments, waitlists, email confirmations, recurring events. Test that RSVPs are blocked when the event is full.

Build a restaurant table reservation web app. Who it's for: a single restaurant taking bookings, plus staff managing them. Core flows: a guest visits the public page → picks date, party size, and an available time slot → enters name/phone to reserve (no login) → staff sign in with Replit Auth to see the day's reservations, mark seated/no-show, and block out slots. Data model: Users (staff); Reservations (id, guest_name, phone, party_size, reserved_at, status [booked/seated/no_show/cancelled], created_at); Settings (open_hours, slot_minutes, max_covers_per_slot). Stack: Replit Auth for staff, Replit Database (Postgres); public reservation flow is unauthenticated. Design: clean guest booking flow and a staff day-view list; mobile-responsive. Scope: guest booking with per-slot capacity, staff day view and status updates. Rule: don't let a slot exceed max covers. Out of scope: table-level assignment, deposits/payments, SMS, multi-location. Run in Plan Mode first and test slot capacity limits.

Build a class booking web app for a studio (e.g. yoga or fitness). Who it's for: members booking scheduled classes and staff running the schedule. Core flows: staff sign in with Replit Auth → create classes with a schedule (title, instructor, start time, duration, capacity) → members sign in → browse upcoming classes → book a spot or join a waitlist if full → cancel a booking (freeing a spot and promoting the first waitlister). Data model: Users (role: staff/member); Classes (id, title, instructor, starts_at, duration_min, capacity); Bookings (id, class_id, member_id, status [booked/waitlisted/cancelled], created_at). Stack: Replit Auth + Replit Database (Postgres). Design: clean weekly schedule grid and a "my bookings" view; mobile-first. Scope: class schedule, booking with capacity + waitlist, cancel with auto-promote. Rule: never overbook capacity; promote the earliest waitlister when a spot frees. Out of scope: payments/passes, recurring class templates, check-in. Test booking to capacity, waitlisting, then cancelling to confirm the waitlister is promoted.

Build a room and resource booking web app for an office. Who it's for: employees reserving meeting rooms and shared resources. Core flows: sign in with Replit Auth → pick a room and a date → see that day's timeline of existing bookings → reserve a free time range (title, start, end) → view and cancel my own bookings. Data model: Users; Rooms (id, name, capacity, location); Bookings (id, room_id, user_id, title, start_at, end_at, created_at). Stack: Replit Auth + Replit Database (Postgres). Design: day-timeline view per room with booked blocks shaded; clean reservation form; mobile-responsive. Scope: rooms, day-timeline view, conflict-free booking, my-bookings management. Rule: reject any booking that overlaps an existing one for the same room. Out of scope: recurring bookings, approvals, calendar sync, resource categories beyond rooms. Run in Plan Mode first and test that overlapping bookings are rejected.

Build a simple two-sided marketplace web app for [category, e.g. handmade goods]. Who it's for: sellers who list items and buyers who browse and enquire. Core flows: anyone can browse and search listings without logging in → sign in with Replit Auth to become a seller → create a listing (title, description, price, category, image URLs, condition) → buyers open a listing and send an enquiry message to the seller → sellers see enquiries on their listings and can mark a listing sold. Data model: Users; Listings (id, seller_id, title, description, price, category, condition, status [active/sold], created_at); Images (id, listing_id, url); Enquiries (id, listing_id, buyer_id, message, created_at). Stack: Replit Auth for sellers/buyers, Replit Database (Postgres); public browsing is unauthenticated. Design: clean marketplace grid with filters (category, price range) and a listing detail page; mobile-first. Scope: public browse/search/filter, seller listings CRUD, buyer enquiries, mark sold. Out of scope: payments/escrow, reviews/ratings, real-time chat, image uploads (use URLs). Run in Plan Mode first, then test browse → enquire → seller sees enquiry.

Build a niche job board web app for [industry/community]. Who it's for: employers posting jobs and candidates browsing and applying. Core flows: anyone can browse and filter jobs (by location, remote, type) without login → sign in with Replit Auth to post a job (title, company, location, remote [y/n], type, description, salary range, apply URL or email) → candidates apply via the linked URL/email → employers see and can close/edit their own posts. Data model: Users (employers); Jobs (id, employer_id, title, company, location, is_remote, employment_type, description, salary_min, salary_max, apply_link, status, created_at). Stack: Replit Auth for employers, Replit Database (Postgres); public job listing/search is unauthenticated. Design: clean job list with filters and a job detail page; mobile-first; SEO-friendly job pages. Scope: public browse/filter/search, employer post/edit/close. Out of scope: in-app applications/resumes, payments to post, alerts/emails, company profiles. Test posting a remote job and filtering to remote-only.

Build a local classifieds web app (Craigslist-style) for [town/community]. Who it's for: locals posting and browsing items and services. Core flows: browse listings by category without login → sign in with Replit Auth to post a listing (title, category, price, description, image URLs, contact method) → posts auto-expire after 30 days → posters can edit, renew, or delete their own listings → browse/search/filter by category and keyword. Data model: Users; Listings (id, user_id, title, category, price, description, contact, status [active/expired], created_at, expires_at); Images (id, listing_id, url). Stack: Replit Auth for posters, Replit Database (Postgres); public browsing is unauthenticated. Design: simple category-driven layout, fast search, clean listing pages; mobile-first. Scope: categories, post/edit/renew/delete, auto-expiry, browse/search. Out of scope: payments, in-app messaging, user ratings, geolocation. Run in Plan Mode first and confirm listings expire after 30 days.

Build a curated directory web app for [niche, e.g. local coffee shops or SaaS tools]. Who it's for: visitors discovering listings and an admin curating them. Core flows: anyone browses, searches, and filters entries by category/tag without login → clicking an entry opens a detail page → an admin signs in with Replit Auth to add, edit, feature, or remove entries → optionally, visitors can submit a suggestion that lands in an admin review queue. Data model: Users (admin); Entries (id, name, description, url, category, tags, image_url, is_featured, status [live/pending], created_at). Stack: Replit Auth for the admin, Replit Database (Postgres); public browsing is unauthenticated. Design: attractive card grid with category filters and a featured section; clean detail pages; mobile-first. Scope: admin CRUD + feature flag, public browse/search/filter, and a submission-to-review queue. Out of scope: user accounts for visitors, payments for featuring, reviews. Test submitting a suggestion and approving it from the admin queue.

Build a discussion forum web app for [community/topic]. Who it's for: members starting threads and replying. Core flows: sign in with Replit Auth → browse categories → open a category to see its threads (sorted by latest activity) → start a new thread (title + body) → reply to a thread → upvote a thread or reply. Data model: Users; Categories (id, name, description); Threads (id, category_id, author_id, title, body, created_at, last_activity_at); Replies (id, thread_id, author_id, body, created_at); Votes (id, user_id, target_type [thread/reply], target_id). Stack: Replit Auth + Replit Database (Postgres). Design: classic clean forum layout — category list, thread list with reply counts, threaded view; mobile-responsive. Scope: categories, threads, single-level replies, and upvotes; a user can vote once per item. Out of scope: nested reply trees, moderation tools, private messages, notifications. Run in Plan Mode first, then test create thread → reply → upvote (and that a second upvote from the same user doesn't double-count).

Build a poll and survey web app. Who it's for: creators who want quick public polls with shareable results. Core flows: sign in with Replit Auth → create a poll (question + 2-10 options, single or multiple choice) → get a public link at /p/[id] → anyone can vote once (no login; prevent obvious repeat votes per browser) → results show live as a bar chart with counts and percentages → creator sees all their polls and can close voting. Data model: Users (creators); Polls (id, creator_id, question, type [single/multiple], status [open/closed], created_at); Options (id, poll_id, label); Votes (id, option_id, voter_key, created_at). Stack: Replit Auth for creators, Replit Database (Postgres); public voting page is unauthenticated. Design: clean voting card and an animated results bar chart; mobile-first. Scope: create poll, public vote with basic repeat-vote prevention, live results, close poll. Out of scope: multi-question surveys, logic/branching, exports, account requirement to vote. Test that results update immediately after a vote.

Build a feature-request / feedback board web app. Who it's for: a product team collecting and prioritizing user ideas. Core flows: sign in with Replit Auth → submit an idea (title, description) → browse ideas sorted by votes → upvote an idea (once per user) → an admin sets a status (Open / Planned / In Progress / Done) and can comment. Data model: Users (role: user/admin); Ideas (id, author_id, title, description, status, vote_count, created_at); Votes (id, idea_id, user_id); Comments (id, idea_id, author_id, body, created_at). Stack: Replit Auth + Replit Database (Postgres). Design: clean board with a big vote button per idea, status badges, and filters by status; mobile-responsive. Scope: submit, one-vote-per-user, sort by votes, admin status + comments. Out of scope: private boards, roadmap timeline view, categories, integrations. Run in Plan Mode first and test that a user can only upvote each idea once.

Build a blog / lightweight CMS web app. Who it's for: a writer who manages posts from a private dashboard and publishes to a public blog. Core flows: sign in with Replit Auth → write a post in a markdown editor (title, slug, body, tags, cover image URL) → save as draft or publish → the public blog lists published posts and shows each at /blog/[slug] → visitors read without logging in. Data model: Users (authors); Posts (id, author_id, title, slug, body_markdown, cover_url, status [draft/published], published_at, created_at); Tags and PostTags. Stack: Replit Auth for the author dashboard, Replit Database (Postgres); the public blog is read-only and unauthenticated. Design: clean, readable blog theme with a tag filter; simple author dashboard; mobile-responsive; SEO-friendly post pages with meta tags. Scope: post CRUD with draft/publish, markdown rendering, public blog + tag pages. Out of scope: comments, multiple author roles, scheduling, image uploads. Test writing a draft, publishing it, and confirming it appears on the public blog at its slug.

Build a members-only content web app. Who it's for: a creator publishing gated posts to registered members. Core flows: sign in with Replit Auth → non-members see post titles/excerpts but full content is locked behind login → members read full posts → an admin publishes posts and can mark a post as free-preview or members-only → members manage a simple profile. Data model: Users (role: admin/member); Posts (id, title, excerpt, body, visibility [public/members], published_at); optional Bookmarks (user_id, post_id). Stack: Replit Auth + Replit Database (Postgres). Design: clean content site with clear locked/unlocked states and a members feed; mobile-responsive. Scope: admin publish, membership gating (public preview vs members-only), member reading + bookmarks. Out of scope: paid subscriptions/billing (gate on login only for now — leave a clear seam to add Stripe later), tiers, email. Run in Plan Mode first and test that members-only content is not reachable when logged out.

Build a minimal SaaS starter web app for [product idea]. Who it's for: a founder validating a paid tool. Core flows: sign in with Replit Auth → land on a dashboard for the core feature [describe the one core feature, e.g. "generate and save X"] → the free plan allows [N] items; upgrading to Pro removes the limit → a billing page shows the current plan. Data model: Users (plan [free/pro]); [CoreEntity] (id, user_id, ...fields...); (leave a Subscriptions table stub for later). Stack: Replit Auth + Replit Database (Postgres). For payments, use Stripe via Replit Integrations with keys stored in Secrets, in test mode — implement a checkout that upgrades the user to Pro; if you'd rather I wire Stripe as a follow-up, gate the plan with a manual flag for now and tell me. Design: clean SaaS dashboard, pricing/upgrade page; mobile-responsive. Scope: auth, the one core feature with a free-tier limit, and a plan/upgrade path. Out of scope: teams, admin panel, email, analytics. Run in Plan Mode first; show the plan and flag anything you need from me (like Stripe keys) before building.