Serverless Database

You are a serverless infrastructure specialist. The user wants to set up and configure a serverless database using PlanetScale, Neon, or Turso.

What to check first

• Verify you have a cloud account (PlanetScale requires MySQL-compatible access, Neon requires PostgreSQL knowledge, Turso uses SQLite)
• Run node --version and npm --version to confirm Node.js is installed for connection pooling libraries
• Check your project has a .env or .env.local file for storing database credentials

Steps

1. Choose your serverless database provider based on your stack: PlanetScale for MySQL workloads, Neon for PostgreSQL with auto-scaling, or Turso for edge-distributed SQLite
2. Create an account and new database instance on your chosen platform's dashboard
3. Generate an API key or access token from your provider's settings page
4. Retrieve the connection string (includes host, username, password, database name) from the platform
5. Store the connection string in your .env.local file as a single DATABASE_URL variable
6. Install the appropriate client library: npm install @planetscale/database for PlanetScale, npm install pg for Neon, or npm install @libsql/client for Turso
7. Create a database connection file that imports the client library and initializes the connection using your DATABASE_URL
8. Test the connection by running a simple query to verify credentials and network access are working

Code

// For PlanetScale with MySQL
import { connect } from '@planetscale/database';

const db = connect({
  url: process.env.DATABASE_URL,
});

export async function queryDatabase(sql, values = []) {
  try {
    const results = await db.execute(sql, values);
    return results.rows;
  } catch (error) {
    console.error('Database query failed:', error);
    throw error;
  }
}

// Usage example
const users = await queryDatabase('SELECT * FROM users WHERE id = ?', [1]);
console.log(users);

// For Neon with PostgreSQL
import { Pool } from 'pg';

const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
  ssl: { rejectUnauthorized: false },
});

export async function queryDatabase(sql, values = []) {
  const client = await pool.connect();
  try {
    const result = await client.query(sql, values);
    return result.rows;
  } finally {
    client.release();
  }
}

// Usage example
const users = await queryDatabase('SELECT * FROM users WHERE id = $1', [1]);
console.log(users);

// For Turso with SQLite
import { createClient } from '@libsql/client';

const db = createClient({
  url: process.env.TURSO_CONNECTION_URL,

Note: this example was truncated in the source. See the GitHub repo for the latest full version.

Common Pitfalls

• Treating this skill as a one-shot solution — most workflows need iteration and verification
• Skipping the verification steps — you don't know it worked until you measure
• Applying this skill without understanding the underlying problem — read the related docs first

When NOT to Use This Skill

• When a simpler manual approach would take less than 10 minutes
• On critical production systems without testing in staging first
• When you don't have permission or authorization to make these changes

How to Verify It Worked

• Run the verification steps documented above
• Compare the output against your expected baseline
• Check logs for any warnings or errors — silent failures are the worst kind

Production Considerations

• Test in staging before deploying to production
• Have a rollback plan — every change should be reversible
• Monitor the affected systems for at least 24 hours after the change