Quickstart

This guide gets AI SaaS Template from download to a running local app with as little friction as possible. The boilerplate already includes the core SaaS plumbing, so local setup is mostly about installing dependencies, loading environment variables, and starting the app. We will use Interview DB as a placeholder product name and interviewdb.com as a placeholder domain, but the workflow is the same for any project built on the boilerplate.

This guide assumes you chose the Tailwind CSS version. If you chose Bootstrap instead, skip the Tailwind-specific steps and keep the Django, database, and deployment steps.

What You Start With

At the top level you will see a structure similar to this:

interview_db/
├── LICENSES.txt
├── Procfile
├── config/
├── interview_db/
├── manage.py
├── package.json
├── requirements/
├── requirements.txt
├── tailwind.config.js
└── .python-version

Inside interview_db/interview_db/, the boilerplate is organized around four main Django apps:

interview_db/interview_db/
├── blog/
├── subscription/
├── tools/
├── users/
├── static/
├── templates/
└── utils/
  • blog: public content, SEO pages, and the TinyMCE-powered admin editor.
  • subscription: pricing, Stripe checkout, billing portal, webhook handling, and plan mapping.
  • tools: an AI feature module, including a streaming OpenAI integration.
  • users: the custom user model, authentication, and account management.

Prerequisites

  • Python 3.13
  • Node.js 20+
  • PostgreSQL
  • A copy of AI SaaS Template
  • A Stripe account if you want to test billing right away
  • An OpenAI API key if you want to test the included AI feature right away

Out of the box, the boilerplate includes:

  • Django 5.2.12
  • Tailwind CSS 4.2.2
  • django-allauth for authentication
  • Stripe for subscriptions
  • Mailgun via Anymail for transactional email
  • TinyMCE for blog authoring

1. Download the boilerplate

Purchase and download the boilerplate from aisaastemplate.com, then unzip it into your working directory.

Unless a section says otherwise, run the commands below from your project root.

2. Create the local database

Install PostgreSQL using your preferred method, then create a database whose name matches your project slug:

createdb interview_db

If your local PostgreSQL setup requires a custom username, password, or host, set DATABASE_URL in your shell before starting Django.

3. Create a virtual environment and install Python dependencies

Install the Python dependencies before you run migrations or start the app:

python -m pip install --upgrade pip
python -m pip install virtualenv
virtualenv -p python3 venv
source venv/bin/activate
pip install -r requirements/local.txt

If you prefer python -m venv, that works too. The boilerplate does not depend on virtualenv specifically.

4. Load the local environment variables

Each project includes a root-level .env file for local secrets. By default it contains placeholders for Stripe and OpenAI:

export STRIPE_PUBLISHABLE_KEY=pk_your_stripe_publishable_key
export STRIPE_SECRET_KEY=sk_your_stripe_secret_key
export STRIPE_ENDPOINT_SECRET=your_stripe_endpoint_secret_for_webhook

export OPENAI_API_KEY=your_openai_api_key

Load those variables into your current shell:

source .env

If you want them loaded every time you activate the virtual environment, append the source command to venv/bin/activate:

echo "source .env" >> venv/bin/activate

The local settings file reads these values from the environment. Keep .env out of version control and replace the placeholders before you test Stripe or OpenAI.

5. Run migrations and start Django

python manage.py migrate
python manage.py createsuperuser
python manage.py runserver

Open http://localhost:8000/ in your browser. The boilerplate includes a compiled output.css, so the app should render with styling even before you install Node dependencies.

In local development, email uses Django's console backend by default. When you test sign-up or email confirmation flows, the email body and verification link will appear in your terminal output.

6. Install the frontend dependencies

If you chose the Tailwind version, install the Node packages and start the watcher:

npm install
npm run watch:css

Use a second terminal window for Django while the Tailwind watcher runs in the first.

For a one-time CSS build, run:

npm run build:css

The included package.json already contains the correct Tailwind CLI commands for your project slug. You do not need to wire Tailwind manually.

7. Verify the full local loop

At this point you should have a usable local baseline:

  • python manage.py runserver serving the app on http://localhost:8000/
  • npm run watch:css rebuilding CSS when you edit templates
  • a working PostgreSQL connection
  • a Django admin user
  • environment variables loaded for Stripe and OpenAI

If the page looks unstyled, hard-refresh the browser with Cmd+Shift+R or restart the Tailwind watcher.

8. Save the baseline in Git

If your unzipped project is not already a Git repository, initialize one and make an initial commit:

git init
git add .
git commit -m "Initial project setup"

Push to GitHub once you are ready to back up the project or connect Heroku automatic deploys.

Next steps