Auto Wired Services on Varity

Varity Team Core Contributors Updated June 2026

When you deploy with Varity, the platform reads your package.json or requirements.txt and automatically provisions the databases and services your app depends on. You do not write any configuration files.

The services start alongside your app when you deploy. No extra steps needed.

How It Works

Varity scans your dependency files for known packages and maps them to services:

1. You add a database library to your project (for example, pg or mongoose)
2. You deploy with varitykit app deploy
3. Varity detects the library and starts the matching service automatically
4. Your app receives the connection URL as an environment variable

You do not configure ports, credentials, or connection strings. Varity handles all of that.

Detection Table

JavaScript and TypeScript (package.json)

Dependency	Service Provisioned	Environment Variable Injected
pg	Postgres database	DATABASE_URL
@prisma/client	Postgres database	DATABASE_URL
drizzle-orm	Postgres database	DATABASE_URL
postgres	Postgres database	DATABASE_URL
ioredis	Redis cache	REDIS_URL
redis	Redis cache	REDIS_URL
@vercel/kv	Redis cache	REDIS_URL
@langchain/ollama	AI model server	OLLAMA_URL
ollama	AI model server	OLLAMA_URL
mongoose	MongoDB database	MONGODB_URI
mongodb	MongoDB database	MONGODB_URI
mysql	MySQL database	MYSQL_URL
mysql2	MySQL database	MYSQL_URL
@aws-sdk/client-s3	Object storage (S3-compatible)	MINIO_URL, MINIO_ACCESS_KEY, MINIO_SECRET_KEY

Python (requirements.txt)

Dependency	Service Provisioned	Environment Variable Injected
psycopg	Postgres database	DATABASE_URL
psycopg2	Postgres database	DATABASE_URL
psycopg2-binary	Postgres database	DATABASE_URL
asyncpg	Postgres database	DATABASE_URL
redis	Redis cache	REDIS_URL
ollama	AI model server	OLLAMA_URL
pymongo	MongoDB database	MONGODB_URI
pymysql	MySQL database	MYSQL_URL
boto3	Object storage (S3-compatible)	MINIO_URL, MINIO_ACCESS_KEY, MINIO_SECRET_KEY
minio	Object storage (S3-compatible)	MINIO_URL, MINIO_ACCESS_KEY, MINIO_SECRET_KEY

Prisma Schema Detection

If your project includes a prisma/schema.prisma file, Varity reads the datasource block to confirm which database to provision:

provider value	Service Provisioned
postgresql	Postgres database
mongodb	MongoDB database

What Each Service Provides

Postgres Database

A relational database for structured data. Includes vector extension support, which means you can store and query embeddings for AI features without any additional setup.

Your app receives DATABASE_URL automatically.

Redis Cache

An in-memory key-value store for caching, sessions, and queues. Ideal for rate limiting, temporary data, and speeding up repeated queries.

Your app receives REDIS_URL automatically.

AI Model Server

A local model runtime so your app can run language models without calling an external API. Useful for apps with on-device inference or privacy requirements.

Your app receives OLLAMA_URL automatically.

MongoDB Database

A document database for flexible, schema-optional data. Good for apps where data shape varies across records.

Your app receives MONGODB_URI automatically.

MySQL Database

A relational database for apps and frameworks that expect MySQL. Auto-provisioned alongside your app when a MySQL client is in your dependencies.

Your app receives MYSQL_URL automatically.

Object Storage

Object storage for files, uploads, and assets. Use it with an S3-compatible SDK or MinIO client. No separate bucket to provision. Auto-wired when your dependencies include an S3 client (@aws-sdk/client-s3, boto3, or minio).

Your app receives MINIO_URL, MINIO_ACCESS_KEY, and MINIO_SECRET_KEY automatically.

Note

Auto-provisioned databases are in beta. They are great for getting an app running end-to-end without standing up a separate database service; bring your own managed database (via environment variables) for workloads that need durability guarantees.

Tip

The services start automatically when you deploy. No configuration needed.

Example: Next.js App with Postgres

If your package.json contains:

{
  "dependencies": {
    "next": "^14.0.0",
    "@prisma/client": "^5.0.0"
  }
}

Running varitykit app deploy will:

1. Detect Next.js as the framework
2. Detect @prisma/client and provision a Postgres database
3. Inject DATABASE_URL into your app’s runtime environment
4. Start both your app and the database together

Your Prisma client will connect automatically using the injected URL.

Example: FastAPI App with Redis and MongoDB

If your requirements.txt contains:

fastapi
redis
pymongo

Running varitykit app deploy will:

1. Detect FastAPI as the framework
2. Detect redis and provision a Redis cache
3. Detect pymongo and provision a MongoDB database
4. Inject REDIS_URL and MONGODB_URI into your runtime environment

Using the Injected Variables

Your app code reads these variables the same way it would in any environment:

Next.js / Node.js

const db = new PrismaClient({
  datasources: { db: { url: process.env.DATABASE_URL } }
});

Python (FastAPI)

import os
from motor.motor_asyncio import AsyncIOMotorClient

client = AsyncIOMotorClient(os.environ["MONGODB_URI"])

The object store speaks the S3 protocol, so point any S3 client at the injected endpoint and credentials:

Object storage (boto3)

import os
import boto3

s3 = boto3.client(
    "s3",
    endpoint_url=os.environ["MINIO_URL"],
    aws_access_key_id=os.environ["MINIO_ACCESS_KEY"],
    aws_secret_access_key=os.environ["MINIO_SECRET_KEY"],
)

You do not need to add these variables to .env files yourself. Varity injects them at deploy time.

Note

Varity filters out platform-specific environment variables from other providers (such as VERCEL_*, RAILWAY_*, NETLIFY_*) so they do not accidentally leak into your deployment.

Related Guides

• Deploy Your App
• Environment Variables
• Supported Frameworks