Self-Hosting Appsmith: Build Internal Business Apps Without Retool Subscriptions

Every growing business eventually hits the same wall: you need internal tools. A customer support dashboard. An admin panel for managing orders. A CRUD interface for that database sitting behind your operations. The traditional answer is to either build these from scratch (expensive, slow) or subscribe to a low-code SaaS platform like Retool (fast, but the per-user pricing adds up quickly).

Appsmith offers a third path. It’s an open-source, low-code application platform licensed under Apache 2.0, and you can run the entire thing on your own server. No per-seat licensing. No data leaving your infrastructure. No vendor lock-in.

In this guide, we’ll walk through what Appsmith does, when it makes sense, how to self-host it with Docker, and how it compares to the SaaS alternatives you might be paying for right now.

What Appsmith Actually Does

Appsmith is a visual application builder. You drag and drop UI widgets — tables, forms, charts, buttons, text inputs — onto a canvas, connect them to your data sources, and wire up interactions with JavaScript snippets. The result is a functional web app that runs in your browser, served from your own server.

The core workflow looks like this:

1. Connect a data source — PostgreSQL, MySQL, MongoDB, Redis, REST APIs, GraphQL endpoints, and more. Appsmith supports dozens of databases and API types out of the box.
2. Write queries — Use SQL, MongoDB queries, or API calls to fetch and manipulate data. Queries are managed in a centralized IDE with autocomplete and linting.
3. Build the UI — Drag widgets onto the canvas. Bind them to query results using `` syntax. A table widget can display rows from a PostgreSQL query. A form widget can submit data back through an INSERT query.
4. Add logic — Write JavaScript functions to handle button clicks, conditional formatting, data transformations, and multi-step workflows.
5. Deploy — Click “Deploy” and the app is live. Share it with your team. Embed it in other applications if needed.

The types of apps businesses typically build with Appsmith include:

• Admin panels for managing users, orders, or content
• Customer dashboards that surface support ticket status and account data
• Inventory trackers connected to a PostgreSQL or MySQL database
• CRUD frontends for any database table that needs human-friendly editing
• Approval workflows with multi-step forms and conditional logic

Why Self-Host Instead of Using Retool Cloud?

Retool is excellent software. It’s also expensive at scale. Retool’s pricing starts at $10/user/month for the Starter plan and climbs to $50+/user/month for higher tiers. If you have 30 internal users across your organization, that’s $3,600–$18,000 per year — for what amounts to a tool builder.

Appsmith’s Community Edition is free, forever, under the Apache 2.0 license. You run it on your own server. The only costs are the server itself (a $10–20/month VPS handles small teams comfortably) and your time to maintain it.

The trade-off is maintenance. With a SaaS platform, someone else handles updates, backups, and uptime. With self-hosted Appsmith, that’s your responsibility. For many small and mid-sized businesses, the savings justify the operational overhead — especially if you’re already self-hosting other tools like n8n, Plausible, or Odoo.

Prerequisites for Self-Hosting

Before you start, you’ll need:

• A Linux server — a VPS with at least 8 GB of RAM. Appsmith runs MongoDB, Redis, and PostgreSQL inside its container by default, so it needs headroom. A $20/month VPS from DigitalOcean, Hetzner, or Linode works well for small teams.
• Docker (version 20.10.7 or later) and Docker Compose (version 1.29.2 or later) installed on the server
• A domain name (optional but recommended) — something like tools.yourcompany.com — so you can set up HTTPS
• Basic command-line comfort — you’ll be running a handful of terminal commands

Step-by-Step: Installing Appsmith with Docker

Step 1: Create the Installation Directory

SSH into your server and create a directory for Appsmith:

mkdir appsmith
cd appsmith

Step 2: Create the Docker Compose File

Create a docker-compose.yml file in the appsmith directory:

version: "3"
services:
  appsmith:
    image: index.docker.io/appsmith/appsmith-ce:v1.98
    container_name: appsmith
    ports:
        - "80:80"
        - "443:443"
    volumes:
        - ./stacks:/appsmith-stacks
    restart: unless-stopped

A few things to note about this configuration:

• appsmith-ce is the Community Edition image, fully open source under Apache 2.0. If you want the Commercial Edition (which includes SSO, audit logs, and granular access control on the free plan), replace appsmith-ce with appsmith-ee. Both are free to use — the Commercial Edition just has more enterprise features.
• v1.98 pins the image to a specific release. Always pin your image tags in production so you control when upgrades happen. Check Appsmith’s GitHub releases for the latest version.
• ./stacks is where all your data lives — app definitions, credentials, user accounts. Back up this directory regularly.

Step 3: Start the Container

docker-compose up -d

Docker will pull the image and start the container. This takes a few minutes on the first run.

Step 4: Create Your Admin Account

Open http://your-server-ip in your browser. You’ll see a setup screen. Fill in your name, email, and password to create the administrator account.

That’s it. Appsmith is running. You can now create your first application.

Step 5: Set Up HTTPS with a Custom Domain (Recommended)

Running internal tools over plain HTTP is a bad idea, especially if they’re accessible over the internet. Appsmith includes built-in SSL certificate management via Let’s Encrypt.

1. Point your domain (e.g., tools.yourcompany.com) to your server’s IP address with an A record.
2. In the Appsmith admin settings (click the gear icon → Settings), navigate to Custom Domain.
3. Enter your domain and save.
4. Appsmith will automatically provision a Let’s Encrypt SSL certificate and redirect HTTP to HTTPS.

If you’re running behind a reverse proxy like Caddy or Traefik (common if you’re already self-hosting other services), configure the proxy to forward traffic to port 80 on the Appsmith container and handle SSL at the proxy level instead.

Building Your First App: A Practical Example

Let’s say you run a small e-commerce operation and you want a simple order management dashboard. Here’s how you’d build it in Appsmith:

1. Connect Your Database

Click Datasources → + New → PostgreSQL. Enter your database credentials:

• Host: your-db-host
• Port: 5432
• Database name: shop
• Username and password

Click Test to verify the connection, then Save.

2. Create a New Application

Click Create New → Give it a name like “Order Dashboard.”

3. Write a Query to Fetch Orders

In the app editor, click + New Query → select your PostgreSQL datasource. Write:

SELECT order_id, customer_name, total_amount, status, created_at
FROM orders
ORDER BY created_at DESC
LIMIT 100;

Name the query getOrders and save it.

4. Add a Table Widget

Drag a Table widget onto the canvas. In the table’s properties, set Table Data to:

The `` syntax binds the table to your query results. When the query runs, the table populates automatically.

5. Add a Search Filter

Drag a Text Input widget above the table. Name it searchInput. Update your query to filter by the search term:

SELECT order_id, customer_name, total_amount, status, created_at
FROM orders
WHERE
  customer_name ILIKE '%' ||  || '%'
  OR order_id::text ILIKE '%' ||  || '%'
ORDER BY created_at DESC
LIMIT 100;

Set the query to run on input change, and now you have a searchable order table.

6. Deploy

Click Deploy. Your app is now live at https://tools.yourcompany.com/applications/order-dashboard. Share the URL with your team.

The whole process — from empty canvas to deployed, searchable dashboard — takes about 15 minutes. No frontend framework. No build pipeline. No deployment config.

Appsmith + n8n: A Powerful Combination

Appsmith becomes even more useful when you pair it with an automation tool like n8n. The pattern is straightforward:

• n8n handles automated workflows — syncing data between systems, processing webhooks, running scheduled tasks
• Appsmith provides the human interface — dashboards to monitor those workflows, forms to trigger them manually, admin panels to manage the data they produce

For example, you might use n8n to automatically sync inventory levels from your supplier’s API into your PostgreSQL database every hour. Then Appsmith displays those levels in a dashboard with low-stock alerts, and lets your warehouse manager manually adjust quantities through a form.

Appsmith also has a Workflows feature built in, which can handle simpler automation scenarios — triggered scripts that run queries, send notifications, or process data. For complex multi-step integrations across multiple services, n8n is still the better tool. For simpler “run this query and send an email” logic, Appsmith’s built-in workflows are sufficient.

Connecting Appsmith to Ollama for AI-Powered Apps

One of Appsmith’s strengths is its ability to call any REST API — including a local Ollama instance. If you’re running Ollama on the same server (or a nearby one), you can build internal apps that leverage local AI without sending data to external APIs.

Here’s a simple example: a customer feedback classifier app.

1. Start Ollama on your server with a model like Llama 3 or Qwen:

   ollama run llama3
   

2. In Appsmith, create a new API datasource pointing to http://localhost:11434/api/generate (Ollama’s default endpoint).

3. Create a query that sends customer feedback to the model:

   {
     "model": "llama3",
     "prompt": "Classify this customer feedback into one of: billing, shipping, product quality, other. Feedback: ",
     "stream": false
   }
   

4. Build the UI — a text area for feedback, a button to classify, and a label that displays the AI’s response.

All processing happens on your server. No data goes to OpenAI, no API costs, no rate limits. For a small business handling dozens of feedback submissions per day, a local LLM is more than sufficient.

Security Considerations

When self-hosting any internal tool, security matters. Here’s a checklist for Appsmith:

Backing Up Your Appsmith Instance

Since all Appsmith data lives in the ./stacks directory, backup is straightforward:

# Stop the container
docker-compose down

# Back up the stacks directory
tar -czf appsmith-backup-$(date +%Y%m%d).tar.gz stacks/

# Restart the container
docker-compose up -d

For automated backups, set up a cron job that runs this script nightly and syncs the archive to an off-site location (like an S3-compatible storage bucket, or simply another server). If you’re already using a tool like restic for backups, just add the stacks/ directory to your backup set.

When Appsmith Is the Wrong Choice

Appsmith isn’t a silver bullet. It’s the wrong tool when:

• You need a public-facing customer app with complex custom branding and marketing pages. Appsmith is designed for internal tools, not customer-facing products. Use a proper web framework or a CMS like Ghost for that.
• Your team has no one comfortable with basic SQL and JavaScript. Appsmith’s low-code approach still requires writing queries and occasional JS functions. If nobody on your team can do that, a no-code platform (or hiring a consultant) might be a better fit.
• You need mobile-native apps. Appsmith builds responsive web apps that work in mobile browsers, but they’re not native mobile apps. If you need iOS/Android apps with offline support, look elsewhere.
• Your data sources are unusual or proprietary. Appsmith supports common databases and API types, but if your data lives in a legacy system with a custom protocol, you may need to build an intermediary API first.

The Real Cost Comparison

Let’s put some numbers on it. Say you have a 20-person team that needs three internal apps: an order management dashboard, a customer support portal, and an inventory tracker.

Retool Cloud (Starter plan, $10/user/month):

• 20 users × $10/month × 12 months = $2,400/year
• Plus you’re sending data to Retool’s servers

Appsmith Self-Hosted:

• VPS (4 GB RAM, sufficient for small team): ~$10/month = $120/year
• Your time for setup and maintenance: ~2 hours initial setup, ~30 minutes/month for updates
• Total: ~$120/year plus minimal ongoing effort

The savings compound as your team grows. At 50 users, Retool Cloud costs $6,000+/year. Appsmith costs the same $120/year regardless of user count.

Getting Started

The fastest way to evaluate Appsmith is to spin it up on a VPS, connect it to a test database, and build one simple app. The Docker installation takes about 10 minutes. If it works for your use case, you can invest the time in setting up proper security, backups, and SSO. If it doesn’t, you’ve spent $10 on a VPS and an hour of time.

The Appsmith documentation is comprehensive, with tutorials for building your first app, connecting data sources, and writing JavaScript. The community forum is active and responsive for troubleshooting.

If you’d like help evaluating whether self-hosted low-code tools make sense for your business — or if you need help setting up Appsmith, n8n, or a full open-source automation stack — reach out to us. We specialize in helping businesses replace SaaS subscriptions with self-hosted open-source alternatives that keep data under your control.