26 Replit Agent Prompts for Internal Tools & Dashboards (2026)

Build an internal admin panel for [company/team]. Who it's for: staff, with two roles — Admin (full access) and Viewer (read-only). Core flow: user logs in with Replit Auth, lands on a dashboard shell with a left nav, and sees only the sections their role allows. Data model: Users(id, email, name, role, created_at) synced from Replit Auth; Records(id, title, status, owner_id, created_at, updated_at) as a placeholder entity. Stack: use Replit Auth for login and roles, Postgres for data, and a clean layout with a sidebar and top bar. Design: clean and modern, primary color [#hex], mobile-responsive, subtle shadows, no clutter. Scope for this pass: auth, role gating, the nav shell, and a working Records CRUD table. Out of scope for now: file uploads, notifications, and any external integrations. Run this in Plan Mode first, show me the Task Plan, and wait for my approval before building.

Add a full CRUD manager for [entity, e.g. "Clients"] to my admin panel. Who it's for: Admins create and edit; Viewers only read. Core flow: a searchable, sortable, paginated table of [Clients] with a "New" button and a row menu for Edit and Delete (with a confirm dialog). Data model: [Clients(id, name, email, phone, company, status[active/inactive], notes, owner_id, created_at, updated_at)]. Requirements: server-side pagination and search across name/email/company; inline validation on the form; enforce role checks on the server, not just the UI. Reuse the existing Replit Auth setup and Postgres. Design: match the current layout and table style. Scope: just this entity's CRUD; do not touch other screens.

Build a user management console for admins. Who it's for: Admins only — block Viewers entirely. Core flow: admin sees a table of all users, can search by name/email, change a user's role, deactivate/reactivate a user, and view when each last signed in. Data model: Users(id, email, name, role[admin/manager/viewer], status[active/suspended], last_login_at, created_at) backed by Replit Auth identities. Rules: an admin cannot demote or suspend their own account (prevent lockout); log every role change to an AuditLog(id, actor_id, action, target_user_id, created_at) table. Stack: Replit Auth, Postgres. Design: clear role badges, a confirm step for suspensions. Scope: user admin only. Out of scope: inviting brand-new external users by email.

Build an internal feature-flag panel. Who it's for: product and engineering admins. Core flow: view all flags in a table, toggle a flag on/off, set a rollout percentage (0-100), restrict a flag to specific user roles, and edit a flag's description. Data model: FeatureFlags(id, key, description, enabled[bool], rollout_pct, allowed_roles[array], updated_by, updated_at); FlagHistory(id, flag_id, change, actor_id, created_at). Provide a simple read endpoint (GET /api/flags) that returns the current flag state as JSON so other apps can consume it. Stack: Replit Auth (admin-only), Postgres. Design: toggles with clear on/off state, a search box, and a history drawer per flag. Scope: managing and reading flags. Out of scope: SDKs or per-flag analytics.

Build a settings editor for our internal apps. Who it's for: Admins edit; Managers read. Core flow: a grouped list of settings (by category), each with a typed value (string, number, boolean, or JSON), inline editing, validation per type, and a Save with a confirmation toast. Data model: Settings(id, category, key, value, value_type, description, updated_by, updated_at). Requirements: validate JSON before saving; keep a Settings audit trail of who changed what; expose GET /api/settings for other services. Any API keys must be stored in Replit Secrets, never in this table. Stack: Replit Auth, Postgres. Design: two-column layout, category nav on the left. Scope: viewing and editing settings only.

Build a read-only audit log viewer. Who it's for: Admins and compliance reviewers. Core flow: a filterable, paginated table of every recorded action, with filters for actor, action type, target entity, and date range, plus a detail drawer showing the full before/after payload. Data model: AuditLog(id, actor_id, actor_email, action, entity_type, entity_id, before_json, after_json, ip, created_at). Requirements: the table is strictly read-only (no edit or delete, even for admins); default the view to the last 7 days; support CSV export of the current filtered result. Stack: Replit Auth, Postgres. Design: monospace for IDs, color-coded action badges. Scope: viewing and exporting logs. Out of scope: writing logs (other tools do that).

Build a KPI dashboard for [company] leadership. Who it's for: Managers and Admins (read-only for everyone). Core flow: land on a dashboard of headline KPIs, pick a date range, and see each metric's current value, trend line, and change vs the prior period. Metrics and formulas: [Revenue = sum(orders.amount where status=paid)], [Active Users = count(distinct users with an event in range)], [New Signups = count(users created in range)], [Churn = churned/active at start]. Data model: read from existing tables [orders, users, events] — do not invent numbers. Requirements: a Definitions section documenting each formula; if a metric has no data for the range, show "no data" rather than zero. Stack: Replit Auth (role-gated), Postgres. Design: KPI cards on top, charts below, a global date-range picker. Scope: read-only reporting. Run in Plan Mode first and confirm the metric formulas with me before building.

Build a sales pipeline dashboard for our revenue team. Who it's for: Sales Managers (full view) and Reps (their own deals only). Core flow: view total pipeline value by stage (funnel), win rate, average deal size, and deals closing this month; filter by rep, region, and date. Data model: read from Deals(id, name, amount, stage[lead/qualified/proposal/won/lost], owner_id, region, expected_close, created_at, closed_at). Requirements: reps see only rows where owner_id = their user; managers see all; compute win rate = won / (won + lost) in the range; show a table of at-risk deals (past expected_close, not closed). Stack: Replit Auth (row-level role scoping), Postgres. Design: funnel chart, KPI cards, and a sortable deals table. Scope: analytics and filtering only — no editing deals here.

Build a support performance dashboard. Who it's for: Support Leads and Admins. Core flow: pick a date range and see ticket volume over time, average first-response time, average resolution time, backlog (open tickets), and CSAT. Data model: read from Tickets(id, subject, status[open/pending/resolved/closed], priority, assignee_id, created_at, first_response_at, resolved_at, csat_score). Requirements: define each metric in a tooltip (e.g. first-response time = first_response_at - created_at); break metrics down by assignee and by priority; flag any metric where more than [20]% of tickets are missing the timestamp it needs, and exclude those from the average rather than treating them as zero. Stack: Replit Auth, Postgres. Design: time-series charts plus a per-agent table. Scope: read-only metrics.

Build a cohort retention explorer. Who it's for: product and growth Managers (read-only). Core flow: choose a cohort grouping (signup month) and an activity event, then see a retention heatmap (cohort rows, period columns) and a retention-curve chart. Data model: read from Users(id, created_at) and Events(id, user_id, type, created_at). Requirements: define "retained in period N" as at least one qualifying event in that period; label cohorts with fewer than [30] users as low-confidence and dim them; let me pick which event type counts as activity; state the definitions on the page. Stack: Replit Auth, Postgres. Design: a clean heatmap with a color legend and hover tooltips. Scope: retention analysis only. Run in Plan Mode first so we agree on the retention definition before building.

Build a read-only reporting portal for non-technical staff. Who it's for: Viewers across departments — strictly read-only, no write access anywhere. Core flow: log in, pick a report from a list, set its parameters (date range, department), view the results as a table plus a summary chart, and download CSV or PDF. Data model: Reports(id, name, description, sql_or_query_key, allowed_roles); read underlying data from [existing tables]. Requirements: reports are predefined by admins (Viewers cannot write queries); every report shows the date range and "generated at" timestamp; enforce allowed_roles per report on the server. Stack: Replit Auth, Postgres. Design: a report gallery, a parameter panel, and a results area. Scope: running and exporting predefined reports. Out of scope: an ad-hoc query builder.

Build a CSV import tool for [entity, e.g. "Products"]. Who it's for: Admins and Managers. Core flow: upload a CSV, map its columns to my fields, see a validation preview (valid rows green, errors red with the reason), then confirm to import only the valid rows. Data model: import into Products(id, sku, name, category, price, stock, active). Validation rules: sku required and unique (flag duplicates against existing rows), price and stock numeric and >= 0, category from an allowed list [list], reject rows over the limit rather than importing partial data silently. Requirements: show a summary (X valid, Y errored) before commit; let me download a CSV of the errored rows with reasons; wrap the import in a transaction so a mid-import failure rolls back. Stack: Replit Auth, Postgres. Design: a clear 3-step wizard (Upload, Map, Review). Scope: importing this entity. Run in Plan Mode first.

Build a fast bulk data-entry tool for [records, e.g. "inventory counts"]. Who it's for: warehouse staff who enter many rows quickly. Core flow: an add-multiple-rows form where each row is [item, location, count], with keyboard-friendly tabbing, add-row on Enter, per-field validation, and a single Save that inserts all valid rows. Data model: [InventoryCounts(id, item_id, location, count, counted_by, counted_at)]. Requirements: validate as they type (count must be a non-negative integer); show a running total of rows entered; keep unsaved rows if validation fails on Save and highlight only the bad ones; record counted_by from Replit Auth automatically. Stack: Replit Auth, Postgres. Design: dense, spreadsheet-like, minimal chrome, works on a tablet. Scope: entry only. Out of scope: editing historical counts.

Build a spreadsheet-style editor for [entity, e.g. "Pricing"]. Who it's for: Managers who edit; Viewers who read. Core flow: an editable grid where clicking a cell edits it in place, edits autosave per cell with a saving/saved indicator, and invalid values revert with an inline message. Data model: [Pricing(id, product_sku, region, price, currency, effective_date, updated_by, updated_at)]. Requirements: optimistic UI with rollback on server error; validate price numeric and > 0; log each cell change to a PricingHistory table (field, old, new, actor, timestamp); support filtering by region and search by sku. Stack: Replit Auth (role-gated editing), Postgres. Design: sticky header row, keyboard navigation between cells. Scope: inline editing of this table. Out of scope: adding or deleting rows here.

Add export and scheduled reports to my internal tool. Who it's for: Managers. Core flow: from any data table, click Export to download the current filtered view as CSV or Excel; and separately, create a Scheduled Report that emails a chosen report as an attachment on a cadence (daily/weekly). Data model: ScheduledReports(id, name, report_key, filters_json, cadence, recipients[array], last_run_at, created_by). Requirements: exports respect the user's role scoping (don't leak rows they can't see); store the email API key (e.g. SendGrid) in Replit Secrets, not in code; deploy the scheduled sender as a Scheduled Deployment (cron) and tell me the schedule. Done looks like: I create a weekly report and receive the email with the correct attachment. Stack: Replit Auth, Postgres, Secrets, Scheduled Deployment. Design: a small "Reports" section. Scope: export + scheduling.

Build a data-quality console for [entity, e.g. "Contacts"]. Who it's for: Admins. Core flow: run checks that surface problems — exact and fuzzy duplicates, missing required fields, and invalid formats (email/phone) — then let me review each issue and resolve it (merge duplicates keeping the most complete record, or fix a field). Data model: read/write Contacts(id, name, email, phone, company, created_at); write a ResolutionLog(id, issue_type, record_ids, action, actor_id, created_at). Requirements: never auto-delete — every merge/fix is a reviewed action and is logged; when merging, show a side-by-side and let me pick the surviving values; report counts by issue type on a summary screen. Stack: Replit Auth, Postgres. Design: an issues list with a resolution drawer. Scope: detection and manual resolution. Run in Plan Mode first.

Build an expense approval tool. Who it's for: Employees submit; Managers approve/reject; Finance does final payout marking. Core flow: employee submits an expense (amount, category, date, receipt note, description) → it appears in their manager's queue → manager approves or rejects with a comment → approved items go to a Finance queue to mark Paid. Data model: Expenses(id, submitter_id, amount, category, date, description, status[submitted/approved/rejected/paid], manager_id, decided_by, decision_note, created_at). State rules: only the assigned manager can decide their reports' expenses; a rejected expense can be edited and resubmitted; every status change is logged with actor and timestamp. Stack: Replit Auth (roles + reporting relationships), Postgres. Design: role-specific queues, status badges, a clear approve/reject bar. Scope: submit → approve → mark paid. Out of scope: accounting integrations. Run in Plan Mode first.

Build a content moderation queue. Who it's for: Moderators (act on items) and Admins (act + configure). Core flow: items awaiting review show in a queue oldest-first; a moderator opens one, sees the content and any report reasons, and picks Approve, Reject, or Escalate with a required note; the item leaves the queue and the decision is recorded. Data model: ModerationItems(id, content_ref, content_snapshot, reported_reason, status[pending/approved/rejected/escalated], assigned_to, decided_by, decision_note, created_at, decided_at). Requirements: claim-to-review so two moderators don't act on the same item (lock on open, release on timeout); keep a full decision history; show per-moderator throughput on an admin view. Stack: Replit Auth, Postgres. Design: a focused review pane with big, clear action buttons and keyboard shortcuts. Scope: the review queue. Out of scope: the system that creates the items.

Build a generic multi-step approval router for [request type, e.g. "access requests"]. Who it's for: Requesters, and a chain of Approvers by role. Core flow: a requester submits a request → it routes through an ordered chain of approver roles [step 1: Manager, step 2: Security, step 3: IT] → each approver approves or rejects with a note → only after all steps approve does status become Granted; any rejection stops the chain. Data model: Requests(id, requester_id, type, details_json, status[pending/granted/rejected], current_step); RequestSteps(id, request_id, step_no, approver_role, decision, decided_by, note, decided_at). Requirements: show each approver only requests at their current step; notify the next approver when a step is approved; log everything. Stack: Replit Auth, Postgres. Design: a stepper showing progress. Scope: the routing engine + queues. Out of scope: provisioning the actual access. Run in Plan Mode first.

Build an employee onboarding tracker. Who it's for: HR/Managers manage; each new hire sees their own checklist. Core flow: create an onboarding record from a template of tasks; each task has an owner (HR, IT, or the hire), a due date, and a done/blocked status; a dashboard shows progress per new hire and overdue tasks across everyone. Data model: Onboardings(id, employee_name, start_date, manager_id, status); Tasks(id, onboarding_id, title, owner_role, assignee_id, due_date, status[todo/done/blocked], completed_at); Templates(id, name, tasks_json). Requirements: apply a template to create tasks in one click; a hire can only update their own tasks; highlight overdue tasks in red on the manager dashboard. Stack: Replit Auth, Postgres. Design: a checklist view per hire and a summary board. Scope: templates, tasks, and progress. Out of scope: HRIS integration.

Build an inventory manager for [warehouse/store]. Who it's for: Staff adjust stock; Managers manage items and see reports. Core flow: browse/search items, view stock per location, record stock movements (receive, sell, adjust, transfer), and get low-stock alerts. Data model: Items(id, sku, name, category, unit, reorder_level); Locations(id, name); StockMovements(id, item_id, location_id, type[receive/sell/adjust/transfer], qty, reason, actor_id, created_at); current stock is the sum of movements per item/location. Requirements: never store a raw editable "quantity" — compute stock from the immutable movement ledger; block a sale/transfer that would go negative unless a Manager overrides with a reason; flag items at or below reorder_level. Stack: Replit Auth, Postgres. Design: an items table with stock badges and a movement form. Scope: items, movements, low-stock. Out of scope: purchasing/PO integration. Run in Plan Mode first.

Build a support-ticket viewer for agents. Who it's for: Agents (work assigned tickets) and Leads (see all, reassign). Core flow: a queue of tickets filterable by status, priority, and assignee; open a ticket to read the thread, add an internal note or a reply, change status, and reassign; a Lead can bulk-reassign. Data model: Tickets(id, subject, requester_email, status[open/pending/resolved/closed], priority, assignee_id, created_at, updated_at); TicketMessages(id, ticket_id, author_id, body, is_internal[bool], created_at). Requirements: agents see their own + unassigned tickets by default; internal notes never show to requesters (mark clearly in the UI); every status/assignee change is timestamped. Stack: Replit Auth, Postgres. Design: a list-and-detail split view, priority color coding. Scope: viewing and working tickets. Out of scope: inbound email ingestion.

Build an IT asset tracker. Who it's for: IT Admins manage; Managers view. Core flow: register assets, assign/check out an asset to a person, check it back in, and see each asset's full custody history and current holder. Data model: Assets(id, asset_tag, type, model, serial, status[available/assigned/repair/retired], purchase_date, warranty_end); Assignments(id, asset_id, user_id, checked_out_at, checked_in_at, condition_note). Requirements: an asset can have at most one open assignment at a time (enforce it); changing status to retired requires a note; warn when warranty_end is within [30] days on the dashboard. Stack: Replit Auth, Postgres. Design: an asset table with status badges and a per-asset history timeline. Scope: assets + custody. Out of scope: procurement and depreciation accounting.

Build an order fulfillment console for ops staff. Who it's for: Fulfillment staff update orders; Managers see all + metrics. Core flow: a board of orders by status (new → picking → packed → shipped → delivered), open an order to see its line items and shipping info, advance its status, and add a tracking number when shipping. Data model: Orders(id, order_number, customer_name, status, shipping_address, tracking_number, created_at, shipped_at); OrderItems(id, order_id, sku, qty, price). Requirements: status can only move forward (or to Cancelled) — block skipping steps unless a Manager overrides; require a tracking number before status can become shipped; log every transition with actor and time. Stack: Replit Auth, Postgres. Design: a Kanban-style board plus a searchable list fallback. Scope: order status + fulfillment. Out of scope: payment processing and the storefront.

Build a vendor and contract register. Who it's for: Procurement/Finance Admins manage; Managers view. Core flow: maintain vendors and their contracts, track renewal dates, and get a dashboard of contracts renewing soon and spend by vendor. Data model: Vendors(id, name, category, contact_name, contact_email, status[active/inactive]); Contracts(id, vendor_id, title, start_date, end_date, auto_renew[bool], annual_value, currency, owner_id, document_note). Requirements: dashboard lists contracts with end_date within [60] days, sorted by soonest; show total annual_value by vendor and by category; store any document links in a field, not the file itself (out of scope). Stack: Replit Auth, Postgres. Design: a vendor list, a contracts table with renewal badges, and a renewals dashboard. Scope: vendors, contracts, renewals view. Out of scope: e-signature and file storage.

Build an internal knowledge base with an admin. Who it's for: Editors write/publish; all staff (Viewers) read published articles. Core flow: editors create articles with a title, category, markdown body, and draft/published status; staff browse by category and full-text search published articles only; editors see drafts too. Data model: Articles(id, title, slug, category, body_md, status[draft/published], author_id, updated_by, updated_at); track a simple version note per save. Requirements: only published articles are visible to Viewers; render markdown safely (escape/sanitize HTML); search across title and body of published articles; show "last updated" on each article. Stack: Replit Auth (Editor vs Viewer), Postgres. Design: a clean reading layout and a distraction-free editor. Scope: authoring, publishing, reading, search. Out of scope: comments and approval workflow.