Documentation

Learn how to use QuickDB to build scalable, serverless applications with MySQL, PostgreSQL, and MongoDB.

Quick Start

Get up and running in 5 minutes

Code Examples

Real-world examples and tutorials

API Reference

Complete API documentation

Quick Start Guide

Create your first database in minutes with QuickDB.

1. Create an Account

Sign up for a free QuickDB account using Google or GitHub.

2. Create Your First Database

Choose your database type and region.

# Install QuickDB CLI
npm install -g @quickdb/cli

# Login to your account
quickdb login

# Create a new database
quickdb create --type mysql --name my-app-db --region us-east-1

# Get your connection string
quickdb info my-app-db

3. Connect to Your Database

Use the connection string to connect from your application.

// Node.js with MySQL
const mysql = require('mysql2/promise');

const connection = await mysql.createConnection({
          host: 'your-db.quickdb.cloud',
  user: 'your-username',
  password: 'your-password',
  database: 'your-database'
});

// Test the connection
const [rows] = await connection.execute('SELECT 1');
console.log('Connected to QuickDB!');

MySQL

Learn how to use MySQL with QuickDB's serverless platform.

Connection

// Using mysql2
const mysql = require('mysql2/promise');

const pool = mysql.createPool({
  host: process.env.QUICKDB_HOST,
  user: process.env.QUICKDB_USER,
  password: process.env.QUICKDB_PASSWORD,
  database: process.env.QUICKDB_DATABASE,
  ssl: {
    rejectUnauthorized: false
  }
});

Basic Operations

// Create a table
await pool.execute(`
  CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
  )
`);

// Insert data
const [result] = await pool.execute(
  'INSERT INTO users (name, email) VALUES (?, ?)',
  ['John Doe', 'john@example.com']
);

// Query data
const [rows] = await pool.execute('SELECT * FROM users WHERE id = ?', [1]);

PostgreSQL

Learn how to use PostgreSQL with QuickDB's serverless platform.

Connection

// Using pg
const { Pool } = require('pg');

const pool = new Pool({
  host: process.env.QUICKDB_HOST,
  user: process.env.QUICKDB_USER,
  password: process.env.QUICKDB_PASSWORD,
  database: process.env.QUICKDB_DATABASE,
  port: 5432,
  ssl: {
    rejectUnauthorized: false
  }
});

Basic Operations

// Create a table
await pool.query(`
  CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
  )
`);

// Insert data
const result = await pool.query(
  'INSERT INTO users (name, email) VALUES ($1, $2) RETURNING *',
  ['John Doe', 'john@example.com']
);

// Query data
const { rows } = await pool.query('SELECT * FROM users WHERE id = $1', [1]);

MongoDB

Learn how to use MongoDB with QuickDB's serverless platform.

Connection

// Using MongoDB driver
const { MongoClient } = require('mongodb');

const client = new MongoClient(process.env.QUICKDB_MONGODB_URI, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

await client.connect();
const db = client.db('your-database');

Basic Operations

// Insert a document
const result = await db.collection('users').insertOne({
  name: 'John Doe',
  email: 'john@example.com',
  created_at: new Date()
});

// Find documents
const users = await db.collection('users').find({
  email: 'john@example.com'
}).toArray();

// Update a document
await db.collection('users').updateOne(
  { email: 'john@example.com' },
  { $set: { name: 'Jane Doe' } }
);

API Reference

Complete REST API documentation for QuickDB.

Authentication

All API requests require authentication using your API key.

curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://api.quickdb.cloud/v1/databases

Create Database

POST /v1/databases

{
  "name": "my-app-db",
  "type": "mysql",
  "region": "us-east-1",
  "version": "8.0"
}

List Databases

GET /v1/databases

Response:
{
  "databases": [
    {
      "id": "db_123",
      "name": "my-app-db",
      "type": "mysql",
      "region": "us-east-1",
      "status": "active",
      "created_at": "2024-01-01T00:00:00Z"
    }
  ]
}

SDKs & Libraries

Official SDKs and community libraries for QuickDB.

JavaScript/Node.js

npm install @quickdb/client

const { QuickDB } = require('@quickdb/client');

const client = new QuickDB({
  apiKey: process.env.QUICKDB_API_KEY
});

const databases = await client.databases.list();

Python

pip install quickdb-client

from quickdb import QuickDB

client = QuickDB(api_key="your-api-key")
databases = client.databases.list()

Go

go get github.com/quickdb/go-client

import "github.com/quickdb/go-client"

client := quickdb.NewClient("your-api-key")
databases, err := client.Databases.List()

PHP

composer require quickdb/php-client

use QuickDB\Client;

$client = new Client('your-api-key');
$databases = $client->databases->list();

Security

Learn about QuickDB's security features and best practices.

Network Security

All connections are encrypted with TLS 1.3
VPC support for private network isolation
IP whitelisting and firewall rules
DDoS protection and rate limiting

Data Security

AES-256 encryption at rest
Automatic backups with point-in-time recovery
Data residency controls
Compliance with SOC2, ISO 27001, GDPR

Access Control

Role-based access control (RBAC)
Multi-factor authentication (MFA)
API key rotation and management
Audit logs for all operations

Deployment

Deploy your applications with QuickDB in various environments.

Environment Variables

# Database connection
QUICKDB_HOST=your-db.quickdb.cloud
QUICKDB_USER=your-username
QUICKDB_PASSWORD=your-password
QUICKDB_DATABASE=your-database

# API access
QUICKDB_API_KEY=your-api-key
QUICKDB_API_URL=https://api.quickdb.cloud

Docker Deployment

FROM node:18-alpine

WORKDIR /app
COPY package*.json ./
RUN npm install

COPY . .
EXPOSE 3000

CMD ["npm", "start"]

# docker-compose.yml
version: '3.8'
services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - QUICKDB_HOST=${QUICKDB_HOST}
      - QUICKDB_USER=${QUICKDB_USER}
      - QUICKDB_PASSWORD=${QUICKDB_PASSWORD}
      - QUICKDB_DATABASE=${QUICKDB_DATABASE}

Kubernetes Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: my-app:latest
        ports:
        - containerPort: 3000
        env:
        - name: QUICKDB_HOST
          valueFrom:
            secretKeyRef:
              name: quickdb-secret
              key: host
        - name: QUICKDB_USER
          valueFrom:
            secretKeyRef:
              name: quickdb-secret
              key: user
        - name: QUICKDB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: quickdb-secret
              key: password