> ## Documentation Index
> Fetch the complete documentation index at: https://docs.rocket.new/llms.txt
> Use this file to discover all available pages before exploring further.

# Build an internal tool

> Build an internal dashboard or admin tool with Rocket.new.

export const LlmsDirective = () => <blockquote className="llms-directive">
    For the complete documentation index, see <a href="/llms.txt">llms.txt</a>.
    For a lightweight markdown version of this page, append .md to the URL.
  </blockquote>;

<LlmsDirective />

A step-by-step recipe for building internal tools with Rocket - admin panels, dashboards, CRM interfaces, inventory managers, and other apps used by your team rather than customers.

<Info>
  Internal tools don't need to be pretty - they need to be functional, fast, and reliable. Focus on data management and workflows over visual polish.
</Info>

## Before you start

Gather these before beginning:

* A clear description of who will use the tool and what they need to do
* The data source (Supabase, an external API, a CSV you'll import)
* The key workflows (what does a user do first, second, third?)
* Any access control requirements (who can see or edit what?)

## The recipe

<Steps>
  <Step title="Define requirements">
    Internal tools succeed when they solve a specific workflow problem. Be concrete about what the tool needs to do.

    **Example requirements for a customer support dashboard:**

    * View all support tickets in a sortable, filterable table
    * Click a ticket to see full conversation history
    * Change ticket status (open, in progress, resolved, closed)
    * Assign tickets to team members
    * See dashboard metrics: open tickets, average response time, tickets resolved today
    * Admin view: manage team members and their permissions

    Write your requirements down. You'll use them in your Build prompt.
  </Step>

  <Step title="Build the core app">
    Create a **Build task** and describe the tool based on your requirements.

    ```plaintext wrap theme={null}
    Build an internal support dashboard. It needs: a data table showing all support tickets with columns for ID, customer name, subject, status, assignee, priority, and created date. The table should be sortable by any column and filterable by status and priority. Clicking a row opens a detail panel showing the full ticket with conversation history. Include a dashboard view with metrics cards: total open tickets, average response time, resolved today, unresolved > 24 hours. Add a sidebar navigation with Dashboard and Tickets sections. Connect to Supabase for the database. Use a clean, functional design - this is for internal use, so prioritize usability over aesthetics.
    ```

    Rocket generates the full app. Preview it and check that the core data flow works: viewing, filtering, and updating records.
  </Step>

  <Step title="Add authentication and access control">
    Internal tools still need auth - you don't want unauthorized access to sensitive data.

    ```plaintext wrap theme={null}
    Add authentication with Supabase Auth. Only users with an @[yourcompany.com] email address can sign up. Add role-based access control: "admin" users can manage team members and change settings, "agent" users can view and manage tickets but not change team settings. Display the logged-in user's name and role in the sidebar header.
    ```

    <Note>
      For internal tools, email domain restriction is often the simplest access control - only people with your company email can access the tool.
    </Note>
  </Step>

  <Step title="Connect your data source">
    Wire the tool to real data.

    <Tabs>
      <Tab title="Supabase">
        If you're using Supabase (the default), your tables are already connected. Ask Rocket to set up the schema:

        ```plaintext wrap theme={null}
        Create Supabase tables for this dashboard: a "tickets" table with columns for id, customer_name, customer_email, subject, description, status (enum: open, in_progress, resolved, closed), priority (enum: low, medium, high, urgent), assignee_id, created_at, updated_at. A "messages" table for ticket conversation history. A "team_members" table for user profiles. Enable row-level security so agents can only see tickets assigned to them, and admins can see all tickets.
        ```
      </Tab>

      <Tab title="External API">
        If your data lives in an external system, connect via API:

        ```plaintext wrap theme={null}
        Connect the dashboard to our API at [api-endpoint]. Fetch tickets from GET /api/tickets. Update ticket status via PUT /api/tickets/:id. Use the API key from environment variables. Handle pagination (the API returns 50 records per page). Add error handling for timeouts and auth failures.
        ```
      </Tab>

      <Tab title="CSV import">
        For one-time data imports or tools that manage static datasets:

        ```plaintext wrap theme={null}
        Add a CSV import feature. Users should be able to upload a CSV file, preview the data in a table, map columns to the correct fields, and import the records into Supabase. Show a progress bar during import and a summary of imported/skipped/errored records when complete.
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Add workflows and actions">
    Internal tools are valuable because they speed up workflows. Add the actions your team performs most.

    ```plaintext wrap theme={null}
    Add these workflow features: bulk actions on the ticket table (select multiple tickets and change status, assign, or delete). A quick-reply feature on the ticket detail panel with canned responses (templates the agent can customize before sending). A notification system that shows a badge when new tickets are created. An activity log on each ticket showing all status changes, assignments, and messages with timestamps.
    ```
  </Step>

  <Step title="Deploy internally">
    Internal tools don't need public-facing SEO or conversion optimization, but they still need reliable deployment.

    1. Test in [staging](/build/launch-web/launch-your-site) with your team
    2. Click **Launch** to deploy
    3. Optionally [connect a custom domain](/build/launch-web/custom-domain) (e.g., support.yourcompany.com)
    4. Share the URL and login credentials with your team
    5. Set up [analytics](/build/measure/analytics) to track usage patterns

    <Info>
      For internal tools, you might skip a custom domain entirely and use the Rocket-provided URL. Bookmark it and share it with the team - no domain configuration needed.
    </Info>
  </Step>
</Steps>

## Internal tool ideas

<CardGroup cols={2}>
  <Card title="CRM" icon="address-book">
    Customer relationship manager with contacts, deal pipeline, activity tracking, and email integration.
  </Card>

  <Card title="Inventory manager" icon="warehouse">
    Stock tracking with categories, suppliers, reorder alerts, and barcode/SKU lookup.
  </Card>

  <Card title="HR portal" icon="id-card">
    Employee directory, PTO requests, onboarding checklists, and document management.
  </Card>

  <Card title="Reporting dashboard" icon="chart-line">
    Business metrics dashboard pulling from multiple data sources with charts, exports, and scheduled reports.
  </Card>
</CardGroup>

## Tips for internal tools

* **Function over form.** Your team needs to get work done, not admire the UI. Prioritize data density, keyboard shortcuts, and fast workflows.
* **Start with the most painful workflow.** Build the tool around the task your team does most and likes least.
* **Add search and filters early.** Internal tools quickly accumulate data. Make it findable from day one.
* **Use real data during development.** Placeholder data hides real problems. Import a sample of production data for testing.
* **Get team feedback in staging.** Share the staging URL with the people who'll actually use the tool. Their feedback matters most.

## What's next?

<CardGroup cols={2}>
  <Card title="Website redesign recipe" icon="paintbrush" href="/learn/recipes/website-redesign">
    Redesign an existing website from audit to deploy.
  </Card>

  <Card title="Security checklist" icon="shield-check" href="/learn/tutorials/security-checklist">
    Lock down auth, API keys, and data access.
  </Card>

  <Card title="Build overview" icon="hammer" href="/build/overview">
    Explore everything Build can create.
  </Card>

  <Card title="Add payments" icon="credit-card" href="/learn/tutorials/adding-payments">
    Add Stripe billing to your internal tool.
  </Card>
</CardGroup>