Forem: Grafbase

Grafbase May 2023 Update

Heather Thacker — Sun, 04 Jun 2023 22:55:53 +0000

Hey there,

May was a huge month at Grafbase. We are excited to share with you all the latest updates, and resources, including our newly released GraphQL Connector and Edge Caching features!

Edge Caching

Add caching to any API using the OpenAPI and GraphQL connectors. Reduce latency with faster responses with Grafbase Edge Caching.

GraphQL Connector

Unify all of your GraphQL APIs into one graph at the edge with the Grafbase Edge Gateway.

Hanko Integration

Grafbase supports Hanko integration with a new JWKS auth provider.

Check out more updates from our changelog:

CLI and OpenAPI Connector Improvements CLI deploys, new flags for creating projects, and many improvements to the OpenAPI Connector, including reduced memory used with introspection queries and resolvers now emitting error logs with exceptions.

Resource Updates

[Guide] Working with resolvers and Vercel Postgres
Create a GraphQL API to handle OpenAI vector embeddings
[Guide] Working with GraphQL and Turso using Edge Resolvers
Leverage the @libsql/client library inside Grafbase resolvers
[Guide] Rate limit ChatGPT API requests with Upstash and Grafbase resolvers
Use Upstash Redis rate limiting through resolvers to prevent costly requests
[Guide] Working with GraphQL, MongoDB Data API and Edge Resolvers
Create a custom GraphQL query and mutation using Edge Resolvers to find and create MongoDB documents using the Data API
[Guide] How to Build a Real-time Chat App with Next.js, GraphQL, and Server-Sent Events
Build a chat app that uses server-sent events to deliver messages to users, with GraphQL Live Queries for streaming messages to the browser
[Guide] Working with mutation resolvers and Stripe Checkout
Create a custom mutation with Edge Resolvers using the server-side Stripe SDK to create a shopping cart checkout

What's Next

Learn about realtime GraphQL with Houdini at Svelte London June 21st.

PS. If you like what we’re building we’d love to hear more about what you think. Join us on Discord, Twitter, YouTube, and GitHub.

I hope you had a great month, and looking forward to what's ahead!

Top 5 tools every frontend developer should be using with GraphQL in 2023

Jamie Barton — Wed, 31 May 2023 08:33:01 +0000

Every week, a bunch of fresh tools, services, and libraries make their debut, claiming to take the GraphQL developer experience to the next level.

Here are my top 5 tools every frontend developer should be using with GraphQL in 2023:

1. Grafbase OpenAPI Connector

Maximize the power of web and mobile app development by effortlessly blending REST and GraphQL APIs with Grafbase. Say goodbye to complexity and hello to a unified GraphQL API that supercharges your app development process.

Enter OpenAPI, formerly known as Swagger - the ultimate game-changer for API definition and documentation. It simplifies things by describing APIs in a format that machines understand, making it easier for developers to work with all kinds of APIs. And with Grafbase Edge Gateway, you can seamlessly merge OpenAPI-driven REST APIs and transform them into GraphQL, taking your stack to a whole new level of awesomeness.

extend schema
  @openapi(
    name: "Stripe"
    schema: "https://raw.githubusercontent.com/stripe/openapi/master/openapi/spec3.json"
    headers: [
      { name: "Authorization", value: "Bearer {{ env.STRIPE_API_KEY }}" }
    ]
  ) {
  query: Query
}

It's free to get started and you don't even need an account to build locally:

npx grafbase init --template openapi-stripe

2. GraphQL Code Generator — Client Preset

The type system in GraphQL is a major game-changer. We can leverage the GraphQL Code Generator to use that same type system to generate TypeScript types so we can build better frontends without error.

In the past, we relied on the GraphQL Code Generator to generate hooks for our existing GraphQL clients. But it was a pain when we wanted to switch to new clients.

The GraphQL Code Generator recommends using the client-preset and TypedDocumentNode to level up our functions and make sure we're getting the correct operation and variable types.

Plus, it's all about keeping operations and fragments in their own components. This approach reduces code complexity, keeps things tidy, and makes it a breeze to switch to any GraphQL client that supports TypedDocumentNode.

export const LessonFragment = graphql(/* GraphQL */ `
  fragment LessonItem on Lesson {
    title
  }
`)

export function Lesson(props: { lesson: FragmentType<typeof LessonFragment> }) {
  const lesson = useFragment(LessonFragment, props.lesson)

  return (
    // Fully typed!
    <li>{lesson.title}</li>
  )
}

3. GQty

Are you tired of the hassle of writing GraphQL operations and configuring codegen for TypeScript? Say goodbye to all that and switch to GQty!

With GQty, you don't even need a separate GraphQL client. It's like magic! GQty takes care of transforming your code into a GraphQL operation behind the scenes. So sit back, relax, and let GQty handle all the heavy lifting for you.

import type { FunctionComponent } from 'react'
import { useQuery } from '../gqty/'

const Query: FunctionComponent = () => {
  const {
    me: { name, friends }
  } = useQuery()

  return (
    <>
      Hello {name}!
      <ol>
        {friends().map(user => (
          <li key={user.id}>{user.name}</li>
        ))}
      </ol>
    </>
  )
}

export default Query

4. GraphQL Network Inspector

The days of struggling to identify /graphql requests in the Network Inspector are over!

GraphQL Network Inspector, an awesome extension for developer tools that makes debugging a breeze.

It categorizes requests into queries, mutations, and subscriptions and even uses the GraphQL operation name. Say goodbye to confusion and hello to simplified debugging.

5. GraphMan

GraphMan takes away all the boring and time-consuming aspects of crafting queries and mutations for a GraphQL API.

With GraphMan, you can effortlessly generate a comprehensive collection from a single GraphQL endpoint. Each collection includes requests for every query and mutation, all conveniently pre-filled variables.

To create a collection, just pass your Grafbase API URL to the command below. It's that easy!

deno run https://deno.land/x/graphman@v1.2.1/src/cli.ts GRAFBASE_API_URL_HERE

Join us at GraphQL Conf

Do you want to learn more about GraphQL? Join us at GraphQL Conf this year. Get your tickets now.

Grafbase April 2023 Update

Heather Thacker — Fri, 05 May 2023 17:26:49 +0000

April was a big month at Grafbase! We are thrilled to share with you all the latest updates, resources, and recap from launch week.

Edge Resolvers

Deploy custom business logic to the edge

Serverless Search

Advanced queries and filters using serverless search

Owner-based Authorization

Build multi-tenant applications with the new owner-based rule

OpenAPI Connector

Connect REST APIs to your unified data layer

CLI Deploys

From idea to production GraphQL API in seconds

Pro Plan

Usage-based billing for the serverless era

Pathfinder

A new way to explore your GraphQL API

Scoped @unique fields

Include additional fields when checking for uniqueness

Product Hunt Launch

We launched public beta on Product Hunt

Resource Updates

[Guide] Working with query resolvers and OpenAI
Create a GraphQL API that exposes a single query resolver to ask OpenAI a question with GPT-3.5
[Guide] Using Remix loader for fetching data
Set up a Remix project and fetch data in a loader on the server
[Guide] Working with Remix actions and GraphQL
Add a form that submits a GraphQL mutation of information through a Remix action
[Guide] Working with field resolvers and Fetch
Create a GraphQL API that stores places and fetch current weather with field resolvers
[Interview] Tinybird and Jamie have a chat
Conversation about Grafbase building a serverless platform and how Tinybird increases development speed while supporting data integration
[Guide] Use Grafbase Edge Resolvers with Neon
Create a GraphQL API and use Grafbase Edge Resolvers with the Neon serverless driver to interact with your database
[Video] Check out Launch Week announcements on Youtube
Check out announcement videos, like this clip about Pathfinder

What's Next

Catch us in Salt Lake City, UT for RemixConf 2023 during May 9-11th.

Hosting a Data Happy Hour in Nashville, TN with Tinybird on May 17, reach out if you are in the area and interested in attending.

PS. If you like what we’re building we’d love to hear more about what you think. Join us on Discord, Twitter, YouTube, and GitHub.

Hope you had a great month, and lastly, here's a team photo from our offsite week in Barcelona, Spain.

Grafbase Public Beta

Jamie Barton — Mon, 24 Apr 2023 08:44:38 +0000

Grafbase is now in Public Beta!

Since launching the Private Beta in July 2022, thousands of early adopters have joined our growing community to help shape and improve the Grafbase platform.

// Detect dark theme var iframe = document.getElementById('tweet-1650416869927534592-845'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1650416869927534592&theme=dark" }

The core feature of the Grafbase platform is the Edge Gateway, a programmable realtime GraphQL API deployed to the edge.

Grafbase March 2023 Update

Heather Thacker — Mon, 03 Apr 2023 11:30:43 +0000

Hey!

We are thrilled to share with you all of the latest product updates, resources, and a preview of what we’re working on next.

Let’s get right into it…

Product Updates

March has been an exciting month packed with feature updates, new resources, and preparing for Launch Week in a couple weeks!

GraphQL Live Queries with Houdini

Build realtime applications faster than ever using GraphQL Live Queries and Houdini GraphQL. Houdini’s Live Queries plugin was the topic of March’s Twitter Space where maintainers Alec and Jean-Yves talked about the process of adding support for Live Queries and what’s ahead for Houdini GraphQL with React.

Pipedream Integration

Build and run event-driven workflows using the Grafbase API. Use thousands of triggers and actions across thousands of apps.

Project Usage

Track usage in the dashboard by viewing metrics around API requests and database units with read, write, and storage. Track these metrics in real-time, and by projects that belong to organizations.

Resource Updates

There were lots of existing updates to the resources helping you build with Grafbase, including videos, guides, and documentation improvements.

[Guide]: Getting started with SvelteKit, Houdini and Grafbase

Setup a SvelteKit application with Houdini GraphQL to automatically add types for fragments, mutations, or queries.

[Guide]: Working with SvelteKit, Houdini and GraphQL Live Queries

Learn how to add Live Queries with the Houdini GraphQL library in a SvelteKit application.

[Guide]: Working with Apollo Client and Relay style pagination

Grafbase exposes a Relay-style pagination API that can be used with other client libraries.

[Guide]: Working cross-platform with Kotlin, GraphQL, and Grafbase

Use Kotlin as a cross-platform layer when building native applications for web, mobile, and desktop.

[Guide]: Using Auth0 as your Identity Provider with Grafbase

Add Auth0 to a frontend application for adaptable authentication and authorization patterns, with Grafbase Identity Provider for requests.

[Docs]: Embedded videos to Quickstart documentation

We’ve added videos to follow along with our Quickstart guide!

What’s next?

We’re working on lots of new features, including search, data explorer, CLI deploys, edge caching, resolvers, owner-based auth, and an OpenAPI connector.

Launch week is April 17 - 21, be on the look out for public beta announcements in April!

Check out the announcement on Twitter

PS. If you like what we’re building we’d love to hear more about what you think. Join us on Discord, Twitter, YouTube, and GitHub.

Grafbase January 2023 Update

Jamie Barton — Thu, 02 Feb 2023 14:06:25 +0000

Hey Dev.to!

We are thrilled to share with you all of the latest product updates, resources, and a preview of what we’re working on next.

Let’s get right to it…

Product Updates

January has been an exciting month packed with lots of feature updates.

Live Queries Grafbase becomes the first hosted GraphQL platform to provide Live Queries. GraphQL Live Queries enable developers to build and deploy realtime apps with ease.
Product Roadmap Since launching the private beta last year, users have been asking about the future of Grafbase product roadmap. We’re super excited to share the public roadmap that you can follow, and even upvote features to be worked on first!
Examples Directory With new examples being created every week we have made it even easier to find the example you’re looking for.
Guides Directory Learn how to build the next generation of web and mobile apps with new guides added every week!

You can see what’s new even quicker by following us on Twitter, browsing the changelog, or joining our Discord server.

Resource Updates

Also in January, there were lots of new documentation, guides, videos, tutorials, and code examples.

[VIDEO]: Serverless GraphQL API with Grafbase by Simon Grimm Learn how to build a mobile application from scratch using Ionic with popular YouTuber Simon Grimm.
[PLUGIN]: URQL Exchange for Live Queries To celebrate the launch of Live Queries we made it even easier so developers don’t need to mess around configuring SSE. Install the custom URQL exchange and go!
[PLUGIN]: Apollo Link for Live Queries We also made it easier for developers using Apollo Client to get going with Live Queries. Add the custom Apollo Link by Grafbase and go!
[EXAMPLE]: Qwik + Qwik City Everyone is talking about how “Qwik” this new framework is so Heather created an example to show how you can fetch data with GraphQL with Qwik City.
[GUIDE]: Build your own low-code GraphQL Admin UI with Retool In this guide, Jamie shows how you can build your own Admin UI to manage Grafbase content using Retool.
[GUIDE]: Working with Eleventy and GraphQL In this guide, Jamie shows how you can use the popular Static Site Generator Eleventy with GraphQL to fetch data from Grafbase.
[WORKSHOP]: Building GraphQL Backends with SDL In this weekly JS Drop by This Dot Labs, Jamie releases a video on you build a GraphQL backend with Grafbase using SDL.

What’s next?

We’re working on lots of new features, including a new directive that lets you write your own resolvers, as well as CLI deploys, data explorer, and much more.

That’s it for January!

PS. If you like what we’re building we’d love to hear more about what you think. Join us on Discord, Twitter, YouTube, and GitHub.

Build realtime GraphQL backends with Grafbase

Jamie Barton — Mon, 16 Jan 2023 16:01:35 +0000

There are developers who don't want the hassle of building a backend, managing deployments, configuring continuous integration, juggling connection pooling, and more.

Grafbase was built to manage all of the above. You get a distributed GraphQL API at the edge by creating a single grafbase/schema.graphql file in your project.

Your schema contains models with special directives to relate data, set default values, validation, and more.

# grafbase/schema.graphql
type Post @model {
  title: String!
  slug: String! @unique
}

In 2021, Laurin Quast introduced a collection of packages to support the use of GraphQL Live Queries on the server and client.

Today, Grafbase is happy to announce it now supports GraphQL Live Queries!

This means that all you need to do to start using GraphQL Live Queries is add @live to your query!

query @live {
  postCollection(first: 10) {
    edges {
      node {
        id
        title
      }
    }
  }
}

The @live directive will observe any changes to the data and send a message using Server-Sent Events with the patch to update the current query state.

The event is in the format of JSON Patch:

{
  "patch": [
    {
      "op": "add",
      "path": "/postCollection/edges/3",
      "value": {
        "node": {
          "id": "post_01GJMDWJ2M6WWTM26S7C1KKYBE",
          "title": "Instant serverless GraphQL backends"
        }
      }
    }
  ],
  "revision": 1
}

Together with The Guild, Grafbase is also releasing 2 new packages (with more on the way) to further abstract the effort needed to implement Live Queries on the frontend.

Starting with support for Apollo Client and URQL, you can add Live Queries with the following packages:

Developers not using either of those libraries can still use Live Queries with the native EventSource API.

Try It Now!

You can try Live Queries by building your own backend in one simple command:

npx grafbase init

Once you've modelled your data using the schema you can run your backend locally to build:

npx grafbase dev

This Week @ Grafbase - Dec 9

Jamie Barton — Fri, 09 Dec 2022 13:18:26 +0000

Happy Friday 🥳

It’s been a few weeks since our last update about what’s going on at Grafbase, and for good reason...

What’s new?

🎮 Dashboard tweaks
We’ve made some significant changes to our Dashboard UI. You should start to see updates rolling out every few days.

🛠️ Bulk Environment Variables
We've made it even easier to add environment variables. Check it out!

🛰️ GraphQL Galaxy
Grafbase Founder & CEO Fredrik Björk spoke at GraphQL Galaxy with other industry experts on the future of server-side GraphQL.

📢 Base64 cursors
Collection queries returning edges will now return a base64 encoded cursor value you can use with the before/after pagination arguments. Learn more about pagination.

🧰 New home for examples
There's a new GitHub repo for all examples! Go check it out.

What’s next?

⚡️ Live Queries
We’re putting the final touches on our realtime GraphQL support. Next week we will introduce this officially. For those keen enough, you can try it out today if you dig around the documentation 😉.

🔢 Improved numeric operations
We’ve made it easier to increment and decrement numeric fields. This change is live in production now but coming to CLI support next week with an official changelog.

GraphQL Galaxy Workshop
In this workshop, we'll cover the basics of GraphQL, and then use that knowledge to build a backend using SDL. Once we've created our schema, we'll run it locally, deploy to production, and create deployment branches for any changes to our schema. We'll finish the workshop by fetching data from our backend from the frontend, as well as adding authentication to lock down data access!
https://graphqlgalaxy.com/workshops-3h

Next week we will introduce some significant changes, including Live Queries, Numeric operations, Improved Documentation, and lots more!

We love to hear from our users what we can be doing better. No matter how small you might think it is, we want to hear from you!

Make sure to click Feedback once logged in and share your thoughts. We read them all!

Have a great weekend! 💚

This Week @ Grafbase - Nov 25

Jamie Barton — Fri, 25 Nov 2022 10:51:57 +0000

Happy Friday 🥳

These posts provide a summary of everything we've been working on this week at Grafbase.

What's new?

🔑 JWT Provider
Today we announced the release of a new auth provider strategy that lets you set a secret to verify JWTs as part of your authorisation strategy.
https://grafbase.com/changelog/jwt-authorization-provider-added

⚒️ New examples!
We've 3 new examples - Fresh, SolidStart, and NextAuth.js Credentials.

📚 New guides!
We have got some new guides! Working with TypeScript, React, and Apollo Client, Username and Password authentication with NextAuth.js.

💚 NuxtNation
The NuxtNation conference was last week and you can replay
https://vi.to/hubs/nuxtnation

We also have a small competition for those who joined NuxtNation. So make sure to checkout the swag link in the email if you attended.

🔥 Cloudflare
We’re excited to continue building Grafbase for scale with Workers by joining the Cloudflare Workers Launchpad!
https://blog.cloudflare.com/launchpad-fall-22/

What's next?

⚡️ Live Queries
General availability for Live Queries is coming very soon! If you'd like early access, please let us know.

🏎️ Performance
We're working on improving the already fast deployment, and API response times.

🎮 Dashboard Updates
You should start to see some improvements to the Dashboard soon.

Stay tuned 👀

Have a great weekend! 👋

This Week @ Grafbase - Nov 11

Jamie Barton — Fri, 11 Nov 2022 16:54:07 +0000

Happy Friday 🥳

This Week @ Grafbase has been all about product, conferences, and realtime!

What's new?

💅 New homepage!!
We wanted to share with everyone what we're building. The homepage shares more about we've created already as well as what's coming next. Check it out and let us know of any feedback.
https://grafbase.com

📆 Date scalar added
You can now use the Date scalar for fields in your models.
https://grafbase.com/changelog/date-scalar-added

🔢 @length directive added
You can now set min and max values for the length of a field value or list.
https://grafbase.com/changelog/length-directive-added

🔐 Model-level authorization rules
You can now override the global @auth rules for each @model in your schema.
https://grafbase.com/docs/reference/directives#model-level-authorization-rules

🗝️ Auth groups claim configuration
You can now set the groupsClaim for group-based auth to use a custom claim different from the default groups claim.
https://grafbase.com/docs/reference/directives#operations

🌉 Jamstack Conf

This week was all about Jamstack Conf! It was a blast to meet the community and see people IRL once again!

Be sure to check jamstack.org/conf to watch all of the the talks when they're published!

What’s next?

💚 NuxtNation is happening!
This event happens November 16 & 17, online!
https://nuxtnation.com

💗 We’re close to releasing the initial version of @live queries! We should have something to show you very, very soon!
Subscribe to the changelog

More exciting updates coming next week!

Have a great weekend 👋

This Week @ Grafbase - Nov 4

Jamie Barton — Fri, 04 Nov 2022 10:10:00 +0000

Happy Friday 🥳

This Week @ Grafbase has been all about product and documentation!

What's new?

🛠️ Docs Quickstart
There is now a Quickstart that you can follow to get up to speed with Grafbase in a few short steps.
https://grafbase.com/docs/quickstart/get-started

🔍 Update and Delete by unique fields
You can now update and delete data by id and any @unique field.
https://grafbase.com/changelog/update-and-delete-by-unique

▲ Next.js conf
We recently sponsored Next.js conf and have a free workshop you can join happening later this month — more info

📈 Funding announcement
You may have already seen but we announced a $7.3m raise to build the data platform of the future.
https://grafbase.com/blog/announcing-7-3m-funding

What's next?

🫐 We're attending and sponsoring Jamstack Conf. There's still tickets available for any last minute attendees. Get 40% off your ticket with code: GRAFBASE40.
https://jamstack.org/conf

💚 We're also sponsoring Nuxt Nation! This event happens November 16 & 17, online!
https://nuxtnation.com

🔓 We're working on more Data Validation topics and investigating how to properly implement migrations, resolvers, and more. Join the community on Discord to have your say on how we should build the data platform for the future!

More exciting updates coming next week!

Have a great weekend 👋

Grafbase: Instant serverless GraphQL backends

Fredrik Björk — Thu, 28 Jul 2022 12:15:00 +0000

As a developer, you are faced with many decisions before your backend is ready for use. What API framework do you use? What database? Where do you deploy your API? Where do you deploy your database? Authorization? What about full-text search? And message queue? We haven't even talked about local development or CI/CD yet. The time to market from idea to production is much longer than it has to be.

We can do better.

We are very excited to announce Grafbase, an edge-native data platform for developers. Our mission is to dramatically simplify and accelerate the development of GraphQL backends.

Grafbase combines GraphQL, Serverless, and Edge Computing to provide a seamless developer experience for shipping backends. Go from idea to serverless GraphQL backend in seconds without spending time on infrastructure.

Getting Started

Run the following command in a new directory:

npx grafbase init

Then populate grafbase/schema.graphql with this schema:

type Todo @model {
  id: ID!
  title: String!
  complete: Boolean!
}

To start your local development environment run this command:

npx grafbase dev

You can interact with your GraphQL API using the Playground, which runs on http://localhost:4000 by default.

Create a new Todo:

mutation {
  todoCreate(input: { title: "Hello, world!", complete: false }) {
    todo {
      id
      title
      complete
    }
  }
}

Congratulations! You have just built your first Todo GraphQL backend.

GraphQL

Frontend and mobile developers love GraphQL. However, building a performant and flexible GraphQL backend can be difficult and time-consuming.

There have been attempts at modernizing GraphQL backend development by building an interface on top of traditional databases. However, this approach involves complex infrastructure, which is asking too much from the developer and takes away from valuable time that could be spent shipping their product.

Grafbase lets you design your GraphQL backend using a declarative approach and watch it come to life in a matter of seconds.

Use powerful GraphQL directives to define models, permissions, caching, validation, and more.

Grafbase will vastly reduce your time to market.

Another benefit of using GraphQL is that you can use any GraphQL client or SDK that you already know.

Your architecture is also vastly simplified since you no longer need to deploy a proxy in front of your traditional database or deal with connection pooling since your backend is served from a GraphQL endpoint via HTTP.

Livin' on the Edge

Jamstack websites are globally fast thanks to pre-rendered content delivered by CDNs. However, dynamic content is predominantly served from APIs deployed to a single region, resulting in suboptimal response times everywhere else.

The Grafbase platform runs on a global edge network to achieve fast response times globally.

To further improve performance, we are planning to offer edge caching for all GraphQL APIs deployed to Grafbase.

GraphQL APIs deployed to Grafbase run on V8 isolates, which means no cold starts. V8 isolates give you the freedom to build your backend using JavaScript or any language that compiles to WebAssembly.

WebAssembly

WebAssembly (Wasm) offers near-native performance with a sandboxed security model and is portable - making it a perfect technology for hosting a GraphQL API at the edge.

Thanks to Wasm and its security model, we allow developers to write business logic in the form of GraphQL resolvers in their language of choice.

Are you an iOS developer and want to code in Swift? An Android developer who loves Kotlin? A Jamstack developer that prefers Deno? The promise of portability is finally here thanks to server-side Wasm.

Jamstack

The Jamstack has removed multiple moving parts and systems to make websites easy to deploy with fast page load times thanks to pre-rendered content delivered by CDNs. In addition, the abstraction layer that the Jamstack and CDNs have provided makes it much easier to ship a static website. But when your application requires dynamic functionality beyond a static page and you need a backend - creating that backend is still not as simple as it should be.

Battle-Tested

Grafbase stands on the shoulders of giants like Cloudflare and AWS to ensure our infrastructure is reliable, performant, and predictable. This lets us focus our energy on building the best developer experience for building and deploying GraphQL backends that scale from startups to enterprises.

The Grafbase platform is built with Rust and runs on rock-solid serverless infrastructure like Cloudflare Workers and DynamoDB. This enables us to offer incredible P99 performance guarantees from day one.

Serverless

On-demand infrastructure and usage-based pricing are the future. However, the tooling and developer experience to adopt serverless is still in the dark ages.

Cloud services like Cloudflare Workers and AWS DynamoDB are very powerful, but the DX is lacking. Grafbase aims to change that by building higher-level abstractions with a developer-first mindset.

Projects deployed to Grafbase come with a globally replicated serverless database seamlessly integrated into every GraphQL API.

Grafbase will offer usage-based pricing that scales to zero. This means you can have hundreds of preview environments for your backend at very low cost.

Local Development

We're building Grafbase with a developer-first mindset to remove friction and make backend development seamless.

npx grafbase dev gives you a zero config local environment that simulates production.

The local development environment hot reloads when detecting changes to files in the grafbase directory for fast iteration of your GraphQL API.

The Grafbase CLI is written in Rust and open-sourced on GitHub.

Branching

Grafbase is deeply integrated with GitHub to provide a modern Git-based workflow for backend development.

Branches are instantly provisioned on serverless infrastructure with production parity.

Deployments take 3 seconds from Git push to live, which enables blazing fast iteration of your backend in isolation before deploying to production.

If you use Vercel or Netlify today, you're already used to this workflow. We were inspired by this approach and offer similar functionality at Grafbase, but geared towards backend development.

What's Next

Over the coming months, we will be working closely with the community to make Grafbase the best platform to build and deploy instant serverless GraphQL backends.

Grafbase is currently in private beta. Sign up for the Private Beta here.

Read our Documentation. Check out the Changelog. Follow us on Twitter and GitHub. Join our Community.