Convex has an [open source version](https://github.com/get-convex/convex-backend) of the backend. We can use this to do local development of an app built on Convex. With local development, you can develop with lower latency, faster push times, and when offline.

## Download the Convex backend binary

Grab the latest binary from [this link](https://github.com/get-convex/convex-backend/releases). You’ll have to pick the appropriate binary for your operating system and CPU architecture. If your architecture isn’t available precompiled, you’ll have to build from source, which we have a guide for [here](https://stack.convex.dev/building-the-oss-backend).

Unzip and run the binary from your terminal

```sh
./convex-local-backend
```

You will know it’s ready when you see a log line like this one:

```sh
2024-03-20T00:06:44.522791Z  INFO common::http: Listening on http://0.0.0.0:3210
```

Keep the backend running in the background and open up a new terminal for the next steps.

# Run `convex dev`

To hit the local OSS backend, `convex dev` needs to know the url and admin key:

```sh
npx convex dev
  --admin-key 0135d8598650f8f5cb0f30c34ec2e2bb62793bc28717c8eb6fb577996d50be5f4281b59181095065c5d0f86a2c31ddbe9b597ec62b47ded69782cd
  --url "http://127.0.0.1:3210"
```

**Note**: This is the default OSS backend admin key. It's ok to check it into source control (and post here 😅).

As a convenience, you can copy the [Justfile](https://github.com/get-convex/convex-backend/blob/main/Justfile) from the open-source repo into your app:

```sh
curl -O https://raw.githubusercontent.com/get-convex/convex-backend/main/Justfile
```

The `Justfile` will add the default URL and admin key to all `just convex` commands. If you don't have `just` installed, instructions [are here](https://github.com/casey/just) - for example `cargo install just` or `brew install just`. In my example, I have an app called `convex-chess`:

```sh
cd convex-chess
npm i
just convex dev
```

Here, we use `just convex dev` instead of `npx convex dev` but any command will work, such as `just convex env`. Note that it is using the version of the Convex CLI specified in the `package.json` of your project. 

Keep this running in the background and open up a new terminal for the next steps.

# Run your frontend

Run the appropriate frontend dev command for your application:

```sh
next dev
```

Voila! You’re up and running with local development. Your application will identify the local URL from the `.env.local` .

# Notes and Limitations

- Upgrading to a newer version of `local-backend` may require wiping your local database. You can do this with `rm convex_local_backend.sqlite3`
- You can run other CLI commands (eg `just convex run`  and `just convex env` ) just as you would via the cloud development flow.

# Related

If you like this, you may also want to check out our other OSS articles

- [https://stack.convex.dev/testing-with-local-oss-backend](https://stack.convex.dev/testing-with-local-oss-backend)
- [https://news.convex.dev/convex-goes-open-source/](https://news.convex.dev/convex-goes-open-source/)

Read this article to learn how you can develop against our open-source backend using our packaged binaries.

Developing with the Open-Source backend

Convex recently released an [open source version](https://github.com/get-convex/convex-backend) of the backend. We can use this to do local development of an app built on Convex. With local development, you can develop with lower latency, faster push times, and when offline.

We’ll be walking through the process of building from source using the steps from the [README](https://github.com/get-convex/convex-backend). Once you have it compiled, you can check out guides for [developing against the local backend](https://stack.convex.dev/developing-with-the-oss-backend) or [testing against it](https://stack.convex.dev/testing-with-local-oss-backend).

# Clone the convex backend repo

```bash
git clone https://github.com/get-convex/convex-backend.git
```

Or if you prefer the GitHub CLI

```bash
gh repo clone get-convex/convex-backend
```

# Install Dependencies

Install cargo, rust, just, node, rush, and JS dependencies. Instructions for installation is taken from the README.

```bash
# Install rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Install NVM
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

# Open a new shell, and install Convex dependencies
cd convex-backend
cargo install just
nvm use
npm install --prefix scripts
just rush install
```

# Compile and run the Convex backend

```protobuf
just run-local-backend
```

This command will compile and run the local Convex backend. Note that it may take a while to fully compile depending on how powerful your machine is. You will know it’s ready when you see a log line like this one:

```protobuf
2024-03-20T00:06:44.522791Z  INFO common::http: Listening on http://0.0.0.0:3210
```

Keep the backend running in the background and open up a new terminal for the next steps.

# Developing against the backend

To develop against the backend, you can use the convenience `Justfile` wrapper command `just convex dev`.

Note that `just convex dev` is just a convenience wrapper that specifies the URL and the default admin key.

```protobuf
npx convex 
  --admin-key 0135d8598650f8f5cb0f30c34ec2e2bb62793bc28717c8eb6fb577996d50be5f4281b59181095065c5d0f86a2c31ddbe9b597ec62b47ded69782cd
  --url "http://127.0.0.1:3210"
```

For more details, check out our post [here](https://stack.convex.dev/developing-with-the-oss-backend) on developing against the backend 

# Notes and Limitations

- Compilation of the local-backend can take a long time and turn your computer into a space heater. We’ve had luck with Apple Silicon Mac hardware, but we encourage you to try different setups and let us know how it goes on our [Community Discord](https://convex.dev/community).
- Upgrading to a newer version of `local-backend` (via `git pull` ) may require wiping your local database. You can do this with `rm convex_local_backend.sqlite3`
- You can run other CLI commands (eg `just convex run`  and `just convex env` ) just as you would via the cloud development flow.

# Related

If you like this, you may also want to check out our other OSS articles

- [https://stack.convex.dev/testing-with-local-oss-backend](https://stack.convex.dev/testing-with-local-oss-backend)
- [https://news.convex.dev/convex-goes-open-source/](https://news.convex.dev/convex-goes-open-source/)

Read this article to learn how you can build our open-source backend from source.

Compiling the Convex Open-Source Backend

Convex now integrates with Fivetran via a [brand new source connector!](https://fivetran.com/docs/databases/convex) This unlocks lots of data engineering use cases for apps built on Convex. Essentially, Convex apps can now replicate data to external data warehouses like Snowflake, Databricks, Google Big Table, and many more from [Fivetran’s destination catalog](https://fivetran.com/docs/destinations).

Check out Fivetran's post on their new integrations and SDKs [here](https://www.fivetran.com/blog/unlocking-third-party-compatibility-with-our-new-sdks).

# OLTP and OLAP Databases

The database at the core of Convex is best suited for Online Transaction Processing (OLTP) use-cases like running a live site and subscribing to realtime queries. Convex is designed to optimize for these use cases so you can build realtime, reactive applications. Data warehouses, on the other hand, are optimized for Online Analytical Processing (OLAP) use-cases like deep analysis on past data. These two types of databases have fundamentally different design.

OLTP databases (like Convex) typically optimize for small, predictable indexed queries. OLTP thrives on point queries (fetching/writing a single document) and indexed range queries over small ranges. OLTP databases often use Optimistic Concurrency Control (OCC) to allow for greater throughput in independent mutations by executing multiple mutations at the same time optimistically, failing them on write if they conflict. OLTP databases often used journaled row-based data structures with auxiliary indexes. This design lends itself to small, fast queries.

OLAP databases (like Snowflake, Databricks, and BigTable) are best suited for large and possibly unpredictable queries like table scans. OLAP databases are typically organized in a column-oriented structure that enables parallel analysis over large amounts of data. High transaction rates and low latency are typically not a priority.

It can even be dangerous to run large analytics queries against OLTP databases. They can result in unpredictable load on the system that could adversely affect your live traffic. Predictability is reliability’s best friend.

# Connecting Convex to Data Warehouses with Fivetran

With the new Convex source connector for Fivetran, you can get the best of both OLTP and OLAP. Build your live application on Convex, then use Fivetran to get your data to your Data Warehouse and Business Intelligence (BI) tools of choice for analysis.

For those who want to just get started quickly, Fivetran with a managed [Google BigQuery offering](https://fivetran.com/docs/destinations/bigquery/managed-bigquery) which works nicely with [Google Looker Studio](https://lookerstudio.google.com/). If you want more control of the setup, you can always choose your own destination.

# Getting Started with Convex+Fivetran

You’ll need a Convex Professional Plan. Learn about the different plans [here](https://www.convex.dev/plans). Then head to your convex dashboard [here](https://dashboard.convex.dev).

## 1. Grab your Convex Credentials

Grab your Deployment Credentials from the Convex deployment [dashboard](https://dashboard.convex.dev) by going to the Settings section on the bottom of the left nav bar. Your deployment credentials will be the first screen that shows up.

![](https://cdn.sanity.io/images/ts10onj4/production/b999e85353f8832d011755ef3cd761ea7362ba50-2502x1196.png?w=1500)

## 2. Set up your Fivetran Connector

Create a Fivetran account and create a new connector. Select the destination of your choice. Select the “Convex” source connector. From there, you drop your credentials in and get syncing.

![](https://cdn.sanity.io/images/ts10onj4/production/698322cd35cec0636996af11baf162dcac568d38-1228x1244.png?w=1200)

# Next Steps

During the early access period, you’ll have to contact us in our [community Discord](https://convex.dev/community) or through support@convex.dev to get started, but it’ll be freely available soon.

We'd love your feedback on the integration as we continue polishing it with the Fivetran team for a beta release.

Launching our official Convex Fivetran connector.

Nipunn Koorapati

All posts by Nipunn