PicoBase vs Nhost

Skip the GraphQL. Ship Faster.

All the backend power without the GraphQL complexity.

Nhost pairs Postgres with Hasura and GraphQL, giving you power at the cost of complexity. PicoBase gives you a relational backend with a simple REST API — no GraphQL, no migrations, no Hasura configuration.

What is Nhost?

Nhost is an open-source Firebase alternative built on Postgres, Hasura (GraphQL engine), and a custom auth service. It provides a GraphQL API, authentication, file storage, and serverless functions. While powerful, it requires knowledge of GraphQL, Postgres migrations, and Hasura permissions to use effectively.

See the Difference in Code

Compare how common tasks look in PicoBase vs Nhost

Initialize the Client

PicoBase
import { createClient } from '@picobase_app/client'

// Zero config — reads from env
const pb = createClient()
Nhost
import { NhostClient } from '@nhost/nhost-js'

const nhost = new NhostClient({
  subdomain: 'your-subdomain',
  region: 'us-east-1',
})

Create a Record

PicoBase
// Collection auto-creates on first write
const post = await pb
  .collection('posts')
  .create({ title: 'Hello', published: true })
Nhost
// Requires Postgres table + Hasura permissions
const INSERT_POST = gql`
  mutation InsertPost(
    $title: String!,
    $published: Boolean!
  ) {
    insert_posts_one(object: {
      title: $title,
      published: $published
    }) {
      id
      title
      published
    }
  }
`

const { data, error } = await nhost.graphql
  .request(INSERT_POST, {
    title: 'Hello',
    published: true,
  })

Query with Filters

PicoBase
const posts = await pb
  .collection('posts')
  .getList(1, 20, {
    filter: 'published = true',
    sort: '-created',
  })
Nhost
const GET_POSTS = gql`
  query GetPosts {
    posts(
      where: { published: { _eq: true } }
      order_by: { created_at: desc }
      limit: 20
    ) {
      id
      title
      published
      created_at
    }
  }
`

const { data, error } = await nhost.graphql
  .request(GET_POSTS)

Authentication

PicoBase
await pb.auth.signUp({
  email: 'user@example.com',
  password: 'secure123',
})

await pb.auth.signIn({
  email: 'user@example.com',
  password: 'secure123',
})
Nhost
await nhost.auth.signUp({
  email: 'user@example.com',
  password: 'secure123',
})

await nhost.auth.signIn({
  email: 'user@example.com',
  password: 'secure123',
})

Realtime Subscriptions

PicoBase
const unsub = await pb
  .collection('messages')
  .subscribe((e) => {
    console.log(e.action, e.record)
  })
Nhost
// Requires GraphQL subscription
const SUBSCRIBE_MESSAGES = gql`
  subscription OnNewMessage {
    messages(order_by: { created_at: desc }) {
      id
      content
      created_at
    }
  }
`

// Typically used with a React hook
// or Apollo subscription client

Feature Comparison

How PicoBase stacks up against Nhost

FeaturePicoBaseNhost

Setup & DX

Zero-config start
Auto-creating collections
No GraphQL knowledge needed
No SQL migrations
TypeScript SDK
Works with AI coding tools

Database

Relational database
GraphQL API
REST API
Realtime subscriptions
No Hasura required
No schema setup required

Auth

Email/password
OAuth providers
Drop-in auth UI
Magic link
SMS auth

Infrastructure

Managed hosting
File storage
Serverless functions
Open source
Self-hostable
Per-tenant isolation
Single-binary deployment

Pricing

Free tier
Paid from
$7/mo
$25/mo
No credit card for free tier

Why Developers Choose PicoBase

No GraphQL Required

Nhost is built on Hasura and requires GraphQL for data operations. PicoBase uses a simple, chainable TypeScript API. No query language to learn.

No SQL Migrations

Nhost requires Postgres migrations and Hasura metadata management. PicoBase collections auto-create. No migration files, no schema syncing.

Simpler Stack

Nhost runs Postgres + Hasura + custom auth under the hood. PicoBase is a single binary with everything built in. Fewer moving parts means fewer things to break.

Lower Entry Price

PicoBase paid plans start at $7/mo vs Nhost's $25/mo Pro plan. More value at every tier.

Better AI Compatibility

GraphQL mutations and queries are notoriously hard for AI coding tools to generate correctly. PicoBase's REST API is simple enough for AI to get right every time.

Single-Binary Self-Hosting

Self-hosting Nhost means running Postgres, Hasura, and auth services. PicoBase is a single Go binary you can deploy anywhere in seconds.

Frequently Asked Questions

Common questions about PicoBase vs Nhost

Do I need to know GraphQL to use PicoBase?

No. PicoBase uses a simple REST API with a chainable TypeScript SDK. There are no GraphQL queries, mutations, or subscriptions to write. If you're tired of writing gql template literals, PicoBase is a welcome change.

Is PicoBase still relational like Nhost?

Yes. Both PicoBase and Nhost use relational databases under the hood. The difference is that PicoBase doesn't require Postgres migrations or a GraphQL engine (Hasura) to access your data. You get the benefits of relational data with a simpler access layer.

Can AI coding tools work with PicoBase better than Nhost?

Yes. GraphQL mutations and queries are notoriously hard for AI tools like Cursor, Claude, and v0 to generate correctly — the syntax is complex and error-prone. PicoBase's REST API and simple filter strings are easy for AI to get right every time.

How does self-hosting PicoBase compare to self-hosting Nhost?

Self-hosting Nhost requires running Postgres, Hasura, an auth service, and potentially more containers. PicoBase is a single Go binary — download it, run it, done. No Docker, no container orchestration, no multi-service management.

Does PicoBase support serverless functions like Nhost?

PicoBase currently focuses on database, auth, realtime, and file storage. For server-side logic, you can pair PicoBase with your existing framework (Next.js API routes, Vercel functions, etc.). Dedicated serverless functions are on our roadmap.

Ready to Try PicoBase?

Join the waitlist and be the first to experience the backend built for flow state.

No credit card required. No setup. Just vibes.