HeliosDB Free Tier Guide

HeliosDB Free Tier Guide

Build Production-Ready Applications at Zero Cost

HeliosDB’s Free Tier provides everything you need to build, test, and deploy applications without spending a dime. This guide covers capabilities, limits, and how to maximize value.

---

What’s Included (Free)

Resource	Free Tier Limit
Storage	500 MB
Compute	2 vCPU-hours/month
Branches	3 active branches
API Calls	100,000/month
Databases	1 database
Vector Operations	10,000/month
Embedding Generations	1,000/month
Cold Start	170ms (same as paid)
All Protocols	PostgreSQL, MySQL, MongoDB, Redis

No credit card required. No trial period. Free forever.

---

Getting Started

Step 1: Create Account

# Install CLI
curl -fsSL https://get.heliosdb.io | sh

# Sign up (no credit card)
helios auth signup --email your@email.com

Or visit console.heliosdb.io/signup

Step 2: Create Free Database

helios db create my-app --tier=free

Or via API:

curl -X POST https://api.heliosdb.io/v1/databases \
  -H "Authorization: Bearer $HELIOS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name": "my-app", "tier": "free"}'

Step 3: Start Building

# Connect with any PostgreSQL client
import psycopg2

conn = psycopg2.connect(
    host="my-app.heliosdb.io",
    database="main",
    user="default",
    password=os.environ["HELIOS_TOKEN"]
)

# You're ready!
cursor = conn.cursor()
cursor.execute("SELECT 'Hello, HeliosDB!'")
print(cursor.fetchone())

---

Free Tier Capabilities

Full Protocol Support

Connect with any client:

# PostgreSQL
psql "postgresql://default:$TOKEN@my-app.heliosdb.io:5432/main"

# MySQL
mysql -h my-app.heliosdb.io -P 3306 -u default -p$TOKEN main

# MongoDB
mongosh "mongodb://default:$TOKEN@my-app.heliosdb.io:27017/main"

# Redis
redis-cli -h my-app.heliosdb.io -p 6379 -a $TOKEN

REST API

Full REST API access:

# Execute SQL
curl -X POST https://my-app.heliosdb.io/api/v1/sql \
  -H "Authorization: Bearer $HELIOS_TOKEN" \
  -d '{"query": "SELECT * FROM users LIMIT 10"}'

# Create tables, insert data, query - everything works

Database Branching

3 branches included:

# Create development branch
helios branch create dev --from main

# Create feature branch
helios branch create feature/auth --from dev

# Full isolation, instant creation (555μs)

Vector/AI Features

1,000 embeddings + 10,000 searches per month:

-- Create vector table
CREATE TABLE docs (
    id UUID PRIMARY KEY,
    content TEXT,
    embedding VECTOR(1536) GENERATED ALWAYS AS (
        helios_embed('openai/text-embedding-3-small', content)
    ) STORED
);

-- Semantic search
SELECT * FROM docs
ORDER BY embedding <-> helios_embed('query text')
LIMIT 5;

Schema Generation

AI-powered schema design:

curl -X POST https://api.heliosdb.io/v1/schema/generate \
  -H "Authorization: Bearer $HELIOS_TOKEN" \
  -d '{
    "description": "Blog with users, posts, and comments",
    "dialect": "postgresql"
  }'

---

Example: Build a Complete App

SaaS Starter (Free Tier)

-- Users table
CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email TEXT UNIQUE NOT NULL,
    password_hash TEXT NOT NULL,
    plan TEXT DEFAULT 'free',
    created_at TIMESTAMPTZ DEFAULT NOW()
);

-- API keys for authentication
CREATE TABLE api_keys (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id UUID REFERENCES users(id) ON DELETE CASCADE,
    key_hash TEXT NOT NULL,
    name TEXT,
    last_used_at TIMESTAMPTZ,
    created_at TIMESTAMPTZ DEFAULT NOW()
);

-- Usage tracking
CREATE TABLE usage (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id UUID REFERENCES users(id),
    endpoint TEXT NOT NULL,
    tokens_used INTEGER DEFAULT 0,
    created_at TIMESTAMPTZ DEFAULT NOW()
);

-- Indexes for performance
CREATE INDEX users_email_idx ON users(email);
CREATE INDEX usage_user_date_idx ON usage(user_id, created_at);

This fits comfortably in 500MB with thousands of users.

AI Chat App (Free Tier)

-- Conversations
CREATE TABLE conversations (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id UUID NOT NULL,
    title TEXT,
    created_at TIMESTAMPTZ DEFAULT NOW()
);

-- Messages with embeddings
CREATE TABLE messages (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    conversation_id UUID REFERENCES conversations(id),
    role TEXT CHECK (role IN ('user', 'assistant', 'system')),
    content TEXT NOT NULL,
    embedding VECTOR(1536) GENERATED ALWAYS AS (
        helios_embed('helios/local-small', content)
    ) STORED,
    created_at TIMESTAMPTZ DEFAULT NOW()
);

-- Knowledge base for RAG
CREATE TABLE knowledge (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    title TEXT,
    content TEXT,
    embedding VECTOR(1536) GENERATED ALWAYS AS (
        helios_embed('helios/local-small', content)
    ) STORED
);

CREATE INDEX messages_embedding_idx ON messages USING hnsw (embedding vector_cosine_ops);
CREATE INDEX knowledge_embedding_idx ON knowledge USING hnsw (embedding vector_cosine_ops);

10,000 vector searches/month supports ~333 queries/day.

E-Commerce Store (Free Tier)

-- Products
CREATE TABLE products (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    name TEXT NOT NULL,
    description TEXT,
    price DECIMAL(10,2) NOT NULL,
    inventory INTEGER DEFAULT 0,
    image_url TEXT,
    created_at TIMESTAMPTZ DEFAULT NOW()
);

-- Orders
CREATE TABLE orders (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id UUID,
    status TEXT DEFAULT 'pending',
    total DECIMAL(10,2) NOT NULL,
    created_at TIMESTAMPTZ DEFAULT NOW()
);

-- Order items
CREATE TABLE order_items (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    order_id UUID REFERENCES orders(id),
    product_id UUID REFERENCES products(id),
    quantity INTEGER NOT NULL,
    price DECIMAL(10,2) NOT NULL
);

-- Sufficient for ~1000 products + 5000 orders with 500MB

---

Maximizing Free Tier Value

1. Efficient Schema Design

-- Use appropriate data types
id UUID                    -- 16 bytes
id BIGSERIAL               -- 8 bytes (better for free tier)

-- Use JSONB sparingly
metadata JSONB             -- Variable, can grow large
category TEXT              -- Fixed, predictable size

-- Compress text when possible
content TEXT               -- Raw text
content_compressed BYTEA   -- Compressed (for large docs)

2. Smart Branching

# Use branches for:
# - Feature development
# - Testing migrations
# - CI/CD pipelines

# Delete when done:
helios branch delete feature/old-feature

# Keep within 3 branch limit

3. Optimize API Calls

# Bad: Many small queries
for user_id in user_ids:
    cursor.execute("SELECT * FROM users WHERE id = %s", [user_id])

# Good: Batch queries
cursor.execute("SELECT * FROM users WHERE id = ANY(%s)", [user_ids])

4. Vector Operation Efficiency

# Bad: Embed on every query
for query in queries:
    search(helios_embed(query))  # Uses embedding quota

# Good: Cache embeddings
query_embedding = helios_embed(query)
# Reuse for multiple searches
results_a = search(query_embedding, table='docs')
results_b = search(query_embedding, table='faq')

5. Use Local Embeddings

-- Free: Local model (no quota impact)
embedding VECTOR(384) GENERATED ALWAYS AS (
    helios_embed('helios/local-small', content)
) STORED

-- Quota: External API
embedding VECTOR(1536) GENERATED ALWAYS AS (
    helios_embed('openai/text-embedding-3-small', content)
) STORED

---

Free Tier Limits

What Counts Against Limits

Action	Counts As
SQL query	1 API call
REST endpoint	1 API call
Vector search	1 vector operation
Embedding generation	1 embedding (external models only)
Branch creation	No cost
Schema generation	1 API call

What Doesn’t Count

• Protocol connections (PostgreSQL, MySQL, MongoDB, Redis)
• Local embedding models (helios/local-*)
• Read queries to system tables
• Monitoring and metrics access

When You Hit Limits

{
  "error": {
    "code": "QUOTA_EXCEEDED",
    "message": "Monthly API call limit reached",
    "current": 100000,
    "limit": 100000,
    "resets_at": "2025-01-01T00:00:00Z"
  }
}

Options:

1. Wait for monthly reset
2. Upgrade to Developer tier ($29/mo)
3. Contact us for startup credits

---

Upgrading from Free

When you’re ready to scale:

# Check current usage
helios usage

# Upgrade to Developer
helios upgrade developer

# Or via console
# console.heliosdb.io/billing

Upgrade Path

Tier	Price	Storage	API Calls	Best For
Free	$0	500 MB	100K	Learning, prototypes
Developer	$29/mo	10 GB	1M	Side projects, MVPs
Team	$199/mo	100 GB	10M	Growing startups
Enterprise	Custom	Unlimited	Unlimited	Scale

No Lock-In

• Export data anytime
• Standard PostgreSQL dump works
• All your code continues to work

# Export your data
pg_dump "postgresql://default:$TOKEN@my-app.heliosdb.io/main" > backup.sql

---

Common Questions

Is the Free Tier really free forever?

Yes. No trial period, no credit card required, no surprise charges. The Free Tier is designed for learning, prototyping, and small projects that stay within limits.

What happens if I exceed limits?

API calls return a 402 error with details about which limit was hit. Your data remains safe and accessible - you just can’t make additional API calls until the limit resets or you upgrade.

Can I have multiple free databases?

Free Tier includes 1 database. For multiple databases, upgrade to Developer ($29/mo) which includes 3 databases.

Is production use allowed?

Yes! Many small apps run successfully on Free Tier. However, for production workloads, we recommend at least Developer tier for:

• Higher limits
• Email support
• SLA guarantees

How do I monitor usage?

# CLI
helios usage

# API
curl https://api.heliosdb.io/v1/usage \
  -H "Authorization: Bearer $HELIOS_TOKEN"

# Console
# console.heliosdb.io/usage

---

Startup Credits

Building a startup? We offer credits beyond Free Tier:

• Y Combinator companies: $10,000 credits
• Techstars companies: $5,000 credits
• Other accelerators: $2,500 credits
• Open source projects: Custom credits

Apply at heliosdb.io/startups

---

Get Started Now

# 30 seconds to your first database
curl -fsSL https://get.heliosdb.io | sh
helios auth signup
helios db create my-app --tier=free
helios connect

# You're live!

Sign Up Free | Documentation | Community Discord

---

HeliosDB Free Tier: Where great ideas start.