Baserow No-Code Database

intermediate

Open source no-code database and Airtable alternative.

Overview

Baserow is an open-source no-code database platform that empowers users to create sophisticated databases and applications without writing code. Founded as a direct alternative to Airtable, Baserow combines the familiar interface of spreadsheets with the power of relational databases, offering collaborative workspaces, custom views, and automated workflows. The platform generates REST APIs automatically for every database, making it ideal for developers who need both no-code convenience and programmatic access. This stack orchestrates Baserow with PostgreSQL as the primary database engine, Redis for caching and session management, and MinIO for S3-compatible file storage. PostgreSQL handles all structured data with ACID compliance and complex query support, while Redis accelerates the user experience through intelligent caching of frequently accessed data and real-time collaboration features. MinIO provides secure, scalable object storage for user uploads, attachments, and media files with full S3 API compatibility. This configuration targets organizations seeking data sovereignty and customization beyond SaaS limitations. Development teams benefit from having both visual database builders for rapid prototyping and full API access for integration work, while enterprises gain complete control over their data infrastructure without vendor lock-in or monthly per-user fees scaling with team growth.

Key Features

Visual database designer with drag-and-drop field creation including text, numbers, dates, files, and formula fields
Real-time collaborative editing with Redis-powered synchronization across multiple users and browser sessions
Automatic REST API generation for every table with authentication, filtering, and pagination built-in
PostgreSQL-backed data integrity with ACID transactions ensuring consistency across complex relational data
S3-compatible file storage via MinIO for handling user uploads, images, and document attachments
Custom views including kanban boards, calendar layouts, gallery views, and filtered table perspectives
Row-level permissions and team workspace management with granular access controls
Database templates and field validation rules with support for complex business logic

Common Use Cases

1Small business CRM systems with contact management, deal tracking, and automated follow-up workflows
2Project management platforms combining task tracking, resource allocation, and team collaboration features
3Content management for marketing teams organizing campaigns, assets, and publication schedules
4Inventory management systems with product catalogs, stock levels, and supplier relationship tracking
5Event planning databases managing venues, vendors, attendees, and logistics coordination
6Research data collection with form generation, participant tracking, and analysis workflow automation
7Customer support ticket systems with automated routing, SLA tracking, and knowledge base integration

Prerequisites

Minimum 4GB RAM (2GB for PostgreSQL, 1GB for Baserow application, 512MB for Redis, 512MB for MinIO)
Docker Engine 20.10+ and Docker Compose v2 with support for health checks and service dependencies
Ports 80, 443, 9000, and 9001 available for Baserow web interface and MinIO console access
Basic understanding of environment variables for configuring database credentials and storage settings
SSL certificate management knowledge if deploying with HTTPS in production environments

For development & testing. Review security settings, change default credentials, and test thoroughly before production use. See Terms

docker-compose.yml

1services: 
2  baserow: 
3    image: baserow/baserow:latest
4    ports: 
5      - "80:80"
6      - "443:443"
7    environment: 
8      BASEROW_PUBLIC_URL: http://localhost
9      DATABASE_HOST: postgres
10      DATABASE_NAME: ${POSTGRES_DB}
11      DATABASE_USER: ${POSTGRES_USER}
12      DATABASE_PASSWORD: ${POSTGRES_PASSWORD}
13      REDIS_HOST: redis
14      SECRET_KEY: ${SECRET_KEY}
15      AWS_ACCESS_KEY_ID: ${MINIO_ACCESS_KEY}
16      AWS_SECRET_ACCESS_KEY: ${MINIO_SECRET_KEY}
17      AWS_STORAGE_BUCKET_NAME: baserow
18      AWS_S3_ENDPOINT_URL: http://minio:9000
19    volumes: 
20      - baserow_data:/baserow/data
21    depends_on: 
22      postgres: 
23        condition: service_healthy
24      redis: 
25        condition: service_started
26    networks: 
27      - baserow-net
28    restart: unless-stopped
29
30  postgres: 
31    image: postgres:16-alpine
32    environment: 
33      POSTGRES_USER: ${POSTGRES_USER}
34      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
35      POSTGRES_DB: ${POSTGRES_DB}
36    volumes: 
37      - postgres_data:/var/lib/postgresql/data
38    healthcheck: 
39      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
40      interval: 10s
41      timeout: 5s
42      retries: 5
43    networks: 
44      - baserow-net
45    restart: unless-stopped
46
47  redis: 
48    image: redis:7-alpine
49    volumes: 
50      - redis_data:/data
51    networks: 
52      - baserow-net
53    restart: unless-stopped
54
55  minio: 
56    image: minio/minio:latest
57    ports: 
58      - "9000:9000"
59      - "9001:9001"
60    environment: 
61      MINIO_ROOT_USER: ${MINIO_ACCESS_KEY}
62      MINIO_ROOT_PASSWORD: ${MINIO_SECRET_KEY}
63    volumes: 
64      - minio_data:/data
65    command: server /data --console-address ":9001"
66    networks: 
67      - baserow-net
68    restart: unless-stopped
69
70volumes: 
71  baserow_data: 
72  postgres_data: 
73  redis_data: 
74  minio_data: 
75
76networks: 
77  baserow-net: 
78    driver: bridge

.env Template

.env

1# PostgreSQL
2POSTGRES_USER=baserow
3POSTGRES_PASSWORD=secure_postgres_password
4POSTGRES_DB=baserow
5
6# Baserow
7SECRET_KEY=$(openssl rand -hex 32)
8
9# MinIO
10MINIO_ACCESS_KEY=minioadmin
11MINIO_SECRET_KEY=secure_minio_password

Usage Notes

1Baserow at http://localhost
2Create account on first visit
3Build databases with drag-and-drop
4REST API automatically generated

Individual Services(4 services)

Copy individual services to mix and match with your existing compose files.

baserow

baserow:
  image: baserow/baserow:latest
  ports:
    - "80:80"
    - "443:443"
  environment:
    BASEROW_PUBLIC_URL: http://localhost
    DATABASE_HOST: postgres
    DATABASE_NAME: ${POSTGRES_DB}
    DATABASE_USER: ${POSTGRES_USER}
    DATABASE_PASSWORD: ${POSTGRES_PASSWORD}
    REDIS_HOST: redis
    SECRET_KEY: ${SECRET_KEY}
    AWS_ACCESS_KEY_ID: ${MINIO_ACCESS_KEY}
    AWS_SECRET_ACCESS_KEY: ${MINIO_SECRET_KEY}
    AWS_STORAGE_BUCKET_NAME: baserow
    AWS_S3_ENDPOINT_URL: http://minio:9000
  volumes:
    - baserow_data:/baserow/data
  depends_on:
    postgres:
      condition: service_healthy
    redis:
      condition: service_started
  networks:
    - baserow-net
  restart: unless-stopped

postgres

postgres:
  image: postgres:16-alpine
  environment:
    POSTGRES_USER: ${POSTGRES_USER}
    POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    POSTGRES_DB: ${POSTGRES_DB}
  volumes:
    - postgres_data:/var/lib/postgresql/data
  healthcheck:
    test:
      - CMD-SHELL
      - pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}
    interval: 10s
    timeout: 5s
    retries: 5
  networks:
    - baserow-net
  restart: unless-stopped

redis

redis:
  image: redis:7-alpine
  volumes:
    - redis_data:/data
  networks:
    - baserow-net
  restart: unless-stopped

minio

minio:
  image: minio/minio:latest
  ports:
    - "9000:9000"
    - "9001:9001"
  environment:
    MINIO_ROOT_USER: ${MINIO_ACCESS_KEY}
    MINIO_ROOT_PASSWORD: ${MINIO_SECRET_KEY}
  volumes:
    - minio_data:/data
  command: server /data --console-address ":9001"
  networks:
    - baserow-net
  restart: unless-stopped

Quick Start

terminal

1# 1. Create the compose file
2cat > docker-compose.yml << 'EOF'
3services:
4  baserow:
5    image: baserow/baserow:latest
6    ports:
7      - "80:80"
8      - "443:443"
9    environment:
10      BASEROW_PUBLIC_URL: http://localhost
11      DATABASE_HOST: postgres
12      DATABASE_NAME: ${POSTGRES_DB}
13      DATABASE_USER: ${POSTGRES_USER}
14      DATABASE_PASSWORD: ${POSTGRES_PASSWORD}
15      REDIS_HOST: redis
16      SECRET_KEY: ${SECRET_KEY}
17      AWS_ACCESS_KEY_ID: ${MINIO_ACCESS_KEY}
18      AWS_SECRET_ACCESS_KEY: ${MINIO_SECRET_KEY}
19      AWS_STORAGE_BUCKET_NAME: baserow
20      AWS_S3_ENDPOINT_URL: http://minio:9000
21    volumes:
22      - baserow_data:/baserow/data
23    depends_on:
24      postgres:
25        condition: service_healthy
26      redis:
27        condition: service_started
28    networks:
29      - baserow-net
30    restart: unless-stopped
31
32  postgres:
33    image: postgres:16-alpine
34    environment:
35      POSTGRES_USER: ${POSTGRES_USER}
36      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
37      POSTGRES_DB: ${POSTGRES_DB}
38    volumes:
39      - postgres_data:/var/lib/postgresql/data
40    healthcheck:
41      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
42      interval: 10s
43      timeout: 5s
44      retries: 5
45    networks:
46      - baserow-net
47    restart: unless-stopped
48
49  redis:
50    image: redis:7-alpine
51    volumes:
52      - redis_data:/data
53    networks:
54      - baserow-net
55    restart: unless-stopped
56
57  minio:
58    image: minio/minio:latest
59    ports:
60      - "9000:9000"
61      - "9001:9001"
62    environment:
63      MINIO_ROOT_USER: ${MINIO_ACCESS_KEY}
64      MINIO_ROOT_PASSWORD: ${MINIO_SECRET_KEY}
65    volumes:
66      - minio_data:/data
67    command: server /data --console-address ":9001"
68    networks:
69      - baserow-net
70    restart: unless-stopped
71
72volumes:
73  baserow_data:
74  postgres_data:
75  redis_data:
76  minio_data:
77
78networks:
79  baserow-net:
80    driver: bridge
81EOF
82
83# 2. Create the .env file
84cat > .env << 'EOF'
85# PostgreSQL
86POSTGRES_USER=baserow
87POSTGRES_PASSWORD=secure_postgres_password
88POSTGRES_DB=baserow
89
90# Baserow
91SECRET_KEY=$(openssl rand -hex 32)
92
93# MinIO
94MINIO_ACCESS_KEY=minioadmin
95MINIO_SECRET_KEY=secure_minio_password
96EOF
97
98# 3. Start the services
99docker compose up -d
100
101# 4. View logs
102docker compose logs -f

One-Liner

Run this command to download and set up the recipe in one step:

terminal

1curl -fsSL https://docker.recipes/api/recipes/baserow-no-code/run | bash

Troubleshooting

Baserow fails to start with database connection errors: Verify PostgreSQL health check passes and POSTGRES_USER/POSTGRES_PASSWORD match DATABASE_USER/DATABASE_PASSWORD exactly
File uploads fail or return 500 errors: Check MinIO container is running and AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY match MINIO_ROOT_USER/MINIO_ROOT_PASSWORD
Real-time collaboration features not working: Ensure Redis container is accessible and REDIS_HOST points to the correct service name in the Docker network
Baserow shows 'bucket does not exist' errors: Access MinIO console at localhost:9001, login with MINIO credentials, and manually create the 'baserow' bucket
PostgreSQL container fails with permission denied: Check that postgres_data volume has correct ownership or remove the volume to recreate with proper permissions
Application performance degrades with multiple users: Increase Redis memory limits and consider PostgreSQL connection pooling by adding BASEROW_DB_OPTIONS environment variable

Community Notes

Loading notes...

Download Recipe Kit

Get all files in a ready-to-deploy package

Includes docker-compose.yml, .env template, README, and license

Components

baserowpostgresqlredisceleryminio

Related Recipes

Ad Space

Shortcuts: C CopyF FavoriteD Download