Baserow: Self-Hosted Airtable Alternative with No Vendor Lock-In

The Problem: Airtable's Pricing Keeps Climbing

Your Airtable bill just jumped from $20/user/month to $45/user/month for Pro, and your team of 15 is now costing you $8,100 annually—just to organize data in spreadsheets. Every time you hit record limits, attachment storage caps, or automation quotas, the solution is the same: upgrade and pay more. Your data is locked in their ecosystem, exports are painful, and you're building your entire workflow on someone else's infrastructure that they can price however they want, whenever they want.

Baserow changes that equation completely. It's an open-source, self-hosted no-code database that gives you everything Airtable offers—relational databases, real-time collaboration, API access, automation—without the recurring fees, arbitrary limits, or vendor lock-in.

What You'll Build

A complete, production-ready no-code database platform featuring:

• Unlimited databases & tables with no record limits
• Real-time collaboration for your entire team
• Relational data with lookups, formulas, and rollups
• API access for integrations and custom applications
• Form builder for data collection
• Views & filters (grid, gallery, kanban, calendar)
• Automation & webhooks for workflow integration
• All self-hosted with complete data ownership

Time to implement: 15-25 minutes Technical level: Beginner to Intermediate Cost savings: $5,000-15,000/year vs. Airtable

Why Self-Host Baserow?

Cost Comparison (15 Users):

Annual Savings with Baserow: $7,500-17,400 for 15 users

Beyond Cost:

• ✅ Unlimited records - No artificial caps on rows or storage
• ✅ Unlimited automation runs - No monthly quota restrictions
• ✅ Full data ownership - Your data never leaves your infrastructure
• ✅ No vendor lock-in - Export anytime, migrate freely
• ✅ Compliance ready - GDPR, HIPAA, SOC2 - you control everything
• ✅ Custom integrations - Full API access with no rate limits
• ✅ White-label ready - Rebrand for your organization

Prerequisites

Before you begin, ensure you have:

• Elestio account (Sign up here)
• Domain name for Baserow (e.g., data.yourcompany.com)
• Email service for user invitations (SMTP credentials)
• Basic understanding of DNS configuration
• Optional: Existing Airtable data to migrate

Architecture Overview

Baserow's architecture consists of:

Users → Web Interface → Backend API → PostgreSQL Database
         ↓                    ↓
    Real-time Sync     File Storage (S3 or Local)
         ↓
    WebSocket Server → Live Collaboration

Components:

• Frontend: Vue.js-based web interface for database management
• Backend: Django REST API handling all operations
• PostgreSQL: Stores database schemas, data, and user information
• Redis: Handles real-time collaboration and caching
• Celery: Background job processing for imports, exports, automation

Step-by-Step Deployment on Elestio

Step 1: Deploy Baserow Instance

On Elestio Dashboard:

1. Navigate to Elestio Services
2. Search for "Baserow"
3. Click "Deploy"
4. Configure your instance:

Basic Configuration:

Service Name: baserow-production
Provider: Choose your preferred cloud (AWS/GCP/Azure/Hetzner)
Region: Closest to your team
Plan: Start with 4GB RAM minimum (recommended for teams)

Domain Setup:

Custom Domain: data.yourcompany.com
Enable SSL: Yes (automatic Let's Encrypt)

Environment Variables:

# Base URL for your instance
BASEROW_PUBLIC_URL=https://data.yourcompany.com

# Database settings (automatically configured by Elestio)
DATABASE_URL=postgresql://baserow:password@postgres:5432/baserow

# Redis for real-time features
REDIS_URL=redis://redis:6379/0

# Email Configuration (for user invitations)
EMAIL_SMTP=True
EMAIL_SMTP_HOST=smtp.sendgrid.net
EMAIL_SMTP_PORT=587
EMAIL_SMTP_USER=apikey
EMAIL_SMTP_PASSWORD=<your-sendgrid-api-key>
EMAIL_SMTP_USE_TLS=True
FROM_EMAIL=noreply@yourcompany.com

# File upload settings
MEDIA_URL=https://data.yourcompany.com/media/
MEDIA_ROOT=/baserow/media

# Optional: S3 for file storage (for large-scale deployments)
# AWS_ACCESS_KEY_ID=your-key
# AWS_SECRET_ACCESS_KEY=your-secret
# AWS_STORAGE_BUCKET_NAME=baserow-files
# AWS_S3_REGION_NAME=us-east-1

5. Click "Deploy Service"
6. Wait 3-5 minutes for deployment to complete

Elestio automatically:

• Provisions the server with PostgreSQL and Redis
• Installs Baserow with all dependencies
• Configures SSL certificates
• Sets up automatic backups
• Provides admin account credentials

Step 2: Initial Admin Setup

Once deployment completes, access your Baserow instance.

First login:

1. Navigate to https://data.yourcompany.com
2. Click "Create new account" (first user becomes admin)
3. Complete registration:

Email: admin@yourcompany.com
Name: Your Name
Password: [Create strong password - min 8 characters]

4. Verify email (check inbox for confirmation link)
5. Log in to access the Baserow dashboard

Initial configuration:

1. Go to Settings (top right menu)
2. Configure:
   • Workspace name: Your company name
   • Time zone: Your team's timezone
   • Language: Default language for interface
   • Date format: MM/DD/YYYY or DD/MM/YYYY

Step 3: Create Your First Database

Let's build a CRM database as an example:

1. Click "Create new database"
2. Name it: Customer Relationship Management
3. Baserow creates your database with a default table

Configure the CRM table:

Click "Add field" to create columns:

Field Name: Company Name
Type: Text
Settings: Primary field ✓

Field Name: Contact Email
Type: Email
Settings: Required ✓

Field Name: Industry
Type: Single Select
Options: Technology, Healthcare, Finance, Retail, Manufacturing

Field Name: Deal Value
Type: Number
Settings:
  - Decimal places: 2
  - Number prefix: $

Field Name: Status
Type: Single Select
Options:
  - Lead (Blue)
  - Qualified (Yellow)
  - Proposal (Orange)
  - Closed Won (Green)
  - Closed Lost (Red)

Field Name: Last Contact
Type: Date
Settings: Include time ✓

Field Name: Next Follow-up
Type: Date
Settings: Send reminder ✓

Field Name: Notes
Type: Long Text
Settings: Enable rich text ✓

Field Name: Assigned To
Type: Link to table (create Users table)
Settings: Allow multiple ✓

Your CRM database is now ready!

Step 4: Set Up Relational Data

Create a related "Users" table:

1. Click "+" to add new table
2. Name: Team Members
3. Add fields:

Name (Text - Primary)
Email (Email)
Department (Single Select: Sales, Marketing, Support)
Role (Single Select: Manager, Rep, Admin)
Photo (File)
Active (Checkbox)

Link tables together:

In your CRM table, the "Assigned To" field now links to Team Members:

• Select a row
• Click "Assigned To" field
• Choose team member(s) from dropdown
• Multiple assignments supported

Add lookup fields:

Field Name: Assignee Email
Type: Lookup
Settings:
  - Link field: Assigned To
  - Lookup field: Email

Now you can see the email of assigned team members directly in the CRM table!

Step 5: Create Different Views

Grid View (Default):

• Spreadsheet-style interface
• Sort, filter, and group data
• Hide/show columns

Gallery View (for visual data):

1. Click "+ Add view" → Gallery
2. Name: Deal Pipeline Visual
3. Configure:
   • Cover field: Company Name
   • Visible fields: Status, Deal Value, Assigned To
   • Card size: Medium

Kanban View (for status tracking):

1. Click "+ Add view" → Kanban
2. Name: Sales Pipeline
3. Configure:
   • Single select field: Status
   • Card fields: Company Name, Deal Value, Assigned To

Drag cards between columns to update status!

Calendar View (for time-based data):

1. Click "+ Add view" → Calendar
2. Name: Follow-up Schedule
3. Configure:
   • Date field: Next Follow-up
   • Display field: Company Name

Form View (for data collection):

1. Click "+ Add view" → Form
2. Name: New Lead Submission
3. Configure form:
   • Title: "Submit New Lead"
   • Description: "Fill out this form to add a new lead to our CRM"
   • Fields to include: Company Name, Contact Email, Industry, Deal Value
   • Required fields: Company Name, Email
   • Submit button text: "Submit Lead"
   • Success message: "Thank you! Lead submitted successfully."

Share form publicly:

• Toggle "Public" switch
• Copy the form URL: https://data.yourcompany.com/form/abc123xyz
• Embed on your website or share via email

Embed form on website:

<iframe
  src="https://data.yourcompany.com/form/abc123xyz"
  width="100%"
  height="800"
  frameborder="0">
</iframe>

Step 6: Set Up Filters and Sorting

Create filtered views for different teams:

Sales Manager View:

1. Duplicate Grid view → Name: My Team's Deals
2. Add filters:
   • Status: is any of → Lead, Qualified, Proposal
   • Deal Value: is greater than → 10000
3. Sort by: Deal Value (descending)
4. Group by: Assigned To

High-Value Opportunities:

1. Create new view → Name: Hot Deals
2. Add filters:
   • Deal Value: is greater than → 50000
   • Status: is any of → Qualified, Proposal
   • Next Follow-up: is within → Next 7 days
3. Sort by: Next Follow-up (ascending)

Overdue Follow-ups:

1. Create new view → Name: Overdue Follow-ups
2. Add filters:
   • Next Follow-up: is before → Today
   • Status: is not → Closed Won, Closed Lost
3. Sort by: Next Follow-up (oldest first)

Step 7: API Access for Integrations

Generate API token:

1. Go to Settings → API Tokens
2. Click "Create token"
3. Configure:
   • Name: Integration Token
   • Workspace: Select your workspace
   • Permissions: Read and Write

Copy your API token (keep it secure!)

Using the Baserow API:

# Get all tables in a database
curl https://data.yourcompany.com/api/database/tables/database/DATABASE_ID/ \
  -H "Authorization: Token YOUR_API_TOKEN"

# List all rows in a table
curl https://data.yourcompany.com/api/database/rows/table/TABLE_ID/ \
  -H "Authorization: Token YOUR_API_TOKEN"

# Create a new row
curl -X POST https://data.yourcompany.com/api/database/rows/table/TABLE_ID/ \
  -H "Authorization: Token YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "field_123": "Acme Corp",
    "field_124": "contact@acme.com",
    "field_125": "Technology",
    "field_126": 25000
  }'

# Update a row
curl -X PATCH https://data.yourcompany.com/api/database/rows/table/TABLE_ID/ROW_ID/ \
  -H "Authorization: Token YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "field_125": "Qualified"
  }'

# Delete a row
curl -X DELETE https://data.yourcompany.com/api/database/rows/table/TABLE_ID/ROW_ID/ \
  -H "Authorization: Token YOUR_API_TOKEN"

Find field IDs:

• Go to any field
• Click settings (gear icon)
• Field ID shown in the URL or settings panel

Step 8: Integrate with N8N for Automation

Connect Baserow to N8N workflows:

Use case: Auto-create Baserow records from form submissions

1. In N8N, create new workflow
2. Add Webhook trigger node
3. Add Baserow node:

// Baserow node configuration
Credentials: Add new Baserow credentials
  - Host: https://data.yourcompany.com
  - API Token: YOUR_API_TOKEN

Operation: Create Row
Database ID: YOUR_DATABASE_ID
Table ID: YOUR_TABLE_ID

Fields to Set:
  Company Name: {{ $json.company }}
  Contact Email: {{ $json.email }}
  Industry: {{ $json.industry }}
  Deal Value: {{ $json.value }}
  Status: "Lead"

4. Add Baserow node (lookup existing):

Operation: Get Rows
Filters:
  field_id: field_124 (email field)
  filter_type: equal
  value: {{ $json.email }}

5. Add IF node to check if contact exists
6. If new: Create row
7. If exists: Update row

Complete N8N workflow example:

Webhook → Check if exists → [IF] → Create new row → Send Slack notification
                              ↓
                         Update existing → Send email to sales rep

Troubleshooting

Issue: Can't Access Baserow After Deployment

Symptoms: Domain doesn't load or shows error page

Solutions:

• ✅ Verify DNS records point to Elestio IP (check domain registrar)
• ✅ Wait 5-10 minutes for SSL certificate generation
• ✅ Check BASEROW_PUBLIC_URL matches your domain exactly
• ✅ Try accessing via IP first to verify server is running
• ✅ Check Elestio logs for startup errors

Issue: Email Invitations Not Sending

Symptoms: Team members don't receive invitation emails

Solutions:

• ✅ Verify SMTP credentials are correct in environment variables
• ✅ Test SMTP connection: telnet smtp.sendgrid.net 587
• ✅ Check FROM_EMAIL is a valid, verified sender address
• ✅ Look for emails in spam folder
• ✅ Check Baserow logs: Look for SMTP connection errors
• ✅ Verify firewall allows outbound connections on port 587

Issue: Slow Performance with Large Tables

Symptoms: Views load slowly, operations take several seconds

Solutions:

• ✅ Upgrade to larger Elestio plan (8GB+ RAM recommended for 100K+ records)
• ✅ Optimize filters: Use indexed fields for filtering
• ✅ Limit visible fields in views (hide unused columns)
• ✅ Reduce number of linked records fetched at once
• ✅ Use pagination instead of loading all rows
• ✅ Consider splitting large tables into multiple related tables
• ✅ Enable PostgreSQL query optimization

Issue: File Uploads Failing

Symptoms: Can't upload attachments to file fields

Solutions:

• ✅ Check available disk space on server
• ✅ Verify MEDIA_ROOT directory has write permissions
• ✅ Increase upload size limit in nginx (if using reverse proxy)
• ✅ Check file size is under limit (default: 10MB per file)
• ✅ For large files: Configure S3 storage instead of local
• ✅ Verify firewall allows file upload requests

Issue: Real-Time Collaboration Not Working

Symptoms: Changes by other users don't appear without refresh

Solutions:

• ✅ Verify Redis is running: Check Elestio service status
• ✅ Check WebSocket connection in browser DevTools (Network tab)
• ✅ Ensure REDIS_URL environment variable is correct
• ✅ Verify firewall allows WebSocket connections
• ✅ Test Redis connection: redis-cli -h redis -p 6379 ping
• ✅ Check browser console for WebSocket errors

Migrating from Airtable

Export your Airtable data:

1. Open your Airtable base
2. Click "..." menu → "Download CSV"
3. Export each table separately
4. Save all CSV files to a folder

Import into Baserow:

1. In Baserow, create new table
2. Click "Import" → "CSV"
3. Upload your CSV file
4. Map columns:
   • Match Airtable field names to Baserow fields
   • Set field types correctly (text, number, date, etc.)
5. Click "Import"
6. Repeat for each table

Recreate relationships:

After importing all tables:

1. Identify linked record fields from Airtable
2. Create "Link to table" fields in Baserow
3. Manually reconnect relationships (or use API script)

Migration script example:

# migrate-airtable-to-baserow.py
import csv
import requests

BASEROW_URL = "https://data.yourcompany.com"
BASEROW_TOKEN = "YOUR_API_TOKEN"
TABLE_ID = "YOUR_TABLE_ID"

headers = {
    "Authorization": f"Token {BASEROW_TOKEN}",
    "Content-Type": "application/json"
}

# Read CSV from Airtable export
with open('airtable_export.csv', 'r') as file:
    reader = csv.DictReader(file)

    for row in reader:
        # Map Airtable fields to Baserow field IDs
        payload = {
            "field_123": row['Company Name'],
            "field_124": row['Contact Email'],
            "field_125": row['Industry'],
            "field_126": float(row['Deal Value'].replace('$', '').replace(',', ''))
        }

        # Create row in Baserow
        response = requests.post(
            f"{BASEROW_URL}/api/database/rows/table/{TABLE_ID}/",
            json=payload,
            headers=headers
        )

        if response.status_code == 200:
            print(f"✅ Imported: {row['Company Name']}")
        else:
            print(f"❌ Failed: {row['Company Name']} - {response.text}")

Run migration:

pip install requests
python migrate-airtable-to-baserow.py

Real-World Use Cases

Project Management

• Task tracking with kanban boards
• Timeline views with calendar
• Resource allocation
• Sprint planning
• Bug tracking

CRM & Sales

• Lead management
• Deal pipeline tracking
• Customer interaction history
• Sales forecasting
• Quote generation

Content Calendar

• Blog post planning
• Social media scheduling
• Content approval workflow
• Editorial calendar
• Performance tracking

Inventory Management

• Stock tracking
• Reorder point alerts
• Supplier management
• Purchase order tracking
• Warehouse locations

Event Management

• Attendee registration
• Venue booking
• Speaker management
• Schedule planning
• Budget tracking

HR & Recruiting

• Applicant tracking
• Interview scheduling
• Candidate scoring
• Onboarding checklists
• Employee directory

Production Best Practices

Security Hardening

Enable two-factor authentication:

1. Go to Settings → Account
2. Enable Two-Factor Authentication
3. Scan QR code with authenticator app
4. Save backup codes

Set up granular permissions:

Admin: Full access to all databases and settings
Builder: Can create/modify databases and tables
Editor: Can add/edit rows, cannot change structure
Viewer: Read-only access to specific views

Configure workspace permissions:

• Restrict database creation to admins
• Limit API token generation
• Enable invite-only workspace access
• Require email verification for new users

Backup Strategy

Automated backups (Elestio handles this):

• Daily PostgreSQL dumps
• 30-day retention policy
• Off-site backup storage
• One-click restore capability

Manual export for redundancy:

1. Export each table as CSV (weekly)
2. Export database schema
3. Store in separate location (S3, Dropbox)

Performance Optimization

Database indexing:

-- For frequently filtered/sorted fields
CREATE INDEX idx_status ON baserow_table_123 (field_status);
CREATE INDEX idx_created ON baserow_table_123 (created_on);

Caching configuration:

• Enable Redis caching for API responses
• Set appropriate TTL values
• Monitor cache hit rates

Resource monitoring:

# Set up alerts for:
# - Database size > 80% of disk
# - Memory usage > 85%
# - CPU usage > 80% for 5+ minutes
# - Response time > 3 seconds

Scaling Considerations

When to scale:

• Database > 100K rows per table
• Team size > 50 users
• API requests > 1000/hour
• File storage > 50GB

Vertical scaling (easiest):

• Upgrade Elestio plan: 4GB → 8GB → 16GB RAM
• Monitor resource usage to predict needs

Horizontal scaling (advanced):

• Separate PostgreSQL to dedicated server
• Use external Redis cluster
• Add read replicas for reporting
• Implement load balancing for API

Cost Analysis

Real-world scenario: 20-person product team

Savings: $30,600 - $70,200 over 3 years

ROI Calculation:

• Time to set up: 2 hours
• Monthly savings: $850-1,950
• Break-even: Day 1

Conclusion

You've just deployed a production-ready, no-code database platform that rivals Airtable—without the recurring fees, record limits, or vendor lock-in. Your team can now build unlimited databases, automate workflows, and collaborate in real-time while maintaining complete control over your data.

This isn't just about cutting costs (though saving $10K-70K over three years is significant). It's about data sovereignty, unlimited scalability, and the freedom to build exactly what your team needs without worrying about hitting artificial limits or surprise price increases.

Ready to escape Airtable's pricing treadmill? Deploy Baserow on Elestio – fully managed, automatically maintained, and ready to use in minutes.

Thanks for reading ❤️ See you in the next one! 👋

Article Specifications:

• Read time: ~12 minutes
• Complexity: Beginner to Intermediate
• Images: 1 header + 2 separators ✅
• Code blocks: 8 production-ready examples
• Prerequisites: 5 items clearly listed
• Troubleshooting: 5 common issues with solutions
• Use cases: 6 real-world scenarios