Deployment

Deployment options

Typeset can be deployed to any platform that supports Next.js applications:

Vercel (recommended) - Zero-config deployment with automatic scaling
Docker - Containerized deployment for any cloud provider
Node.js server - Traditional server deployment
AWS, GCP, Azure - Cloud platform deployments

This guide covers Vercel (recommended) and Docker deployments.

Deploy to Vercel

Vercel is the recommended deployment platform for Typeset. It provides:

Automatic HTTPS certificates
Global CDN for static assets
Serverless API routes with auto-scaling
Zero-config deployment
Built-in analytics and monitoring

Install Vercel CLI

npm install -g vercel

Or use the included dependency:

pnpm vercel

vercel login

Follow the prompts to authenticate with your Vercel account.

Deploy

From your project directory:

vercel

This will:

Build your Next.js application
Upload the build to Vercel
Provide a preview URL

For production deployment:

vercel --prod

Configure environment variables

Add environment variables in the Vercel dashboard:

Go to your project settings
Navigate to Environment Variables
Add each variable:

NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY=pk_live_...
CLERK_SECRET_KEY=sk_live_...
LIVEBLOCKS_SECRET_KEY=sk_...
NEXT_PUBLIC_LIVEBLOCKS_PUBLIC_KEY=pk_...
OPENAI_API_KEY=sk-proj-...
GOOGLE_API_KEY=AIza...

Use production API keys (not test keys) for your production deployment.

Configure custom domain

In the Vercel dashboard:

Go to Settings → Domains
Add your custom domain
Configure DNS records as instructed
Wait for SSL certificate provisioning (automatic)

Vercel deployment via GitHub

For continuous deployment:

Push to GitHub

Push your Typeset repository to GitHub:

git remote add origin https://github.com/yourusername/typeset.git
git push -u origin main

Import to Vercel

Go to vercel.com/new
Click Import Git Repository
Select your repository
Configure project settings (automatic for Next.js)
Add environment variables
Click Deploy

Automatic deployments

Vercel will automatically deploy:

Production: Commits to main branch
Preview: Commits to other branches and pull requests

Vercel configuration

Create vercel.json in your project root for advanced configuration:

vercel.json

{
  "buildCommand": "pnpm build",
  "devCommand": "pnpm dev",
  "installCommand": "pnpm install",
  "framework": "nextjs",
  "regions": ["iad1"],
  "env": {
    "NEXT_PUBLIC_APP_URL": "https://your-domain.com"
  }
}

Configuration options:

regions - Deployment regions (e.g., iad1 for US East)
buildCommand - Custom build command
installCommand - Custom package installation
functions - Serverless function configuration

Tectonic binary on Vercel

Vercel’s serverless functions have a 50 MB deployment size limit. The Tectonic binary (~35 MB) fits within this limit.

The Tectonic binary must be included in your deployment:

Ensure bin/tectonic is committed to your repository

Verify the binary is executable:

chmod +x bin/tectonic
git add bin/tectonic
git commit -m "Add Tectonic binary"

The binary will be included in the deployment automatically

Vercel limits:

Max deployment size: 50 MB (Typeset with Tectonic: ~40 MB)
Max function size: 50 MB
/tmp storage: 512 MB (for LaTeX package cache)
Function timeout: 10 seconds (Hobby), 60 seconds (Pro), 900 seconds (Enterprise)

LaTeX compilation may timeout on Vercel Hobby plan (10 seconds). Upgrade to Pro for 60-second function execution.

Deploy with Docker

Deploy Typeset as a containerized application:

Create Dockerfile

Create Dockerfile in your project root:

Dockerfile

FROM node:20-alpine AS base

# Install dependencies only when needed
FROM base AS deps
RUN apk add --no-cache libc6-compat
WORKDIR /app

# Install pnpm
RUN npm install -g pnpm

# Copy package files
COPY package.json pnpm-lock.yaml pnpm-workspace.yaml ./
RUN pnpm install --frozen-lockfile

# Builder stage
FROM base AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY . .

# Build Next.js application
RUN npm install -g pnpm && pnpm build

# Production stage
FROM base AS runner
WORKDIR /app

ENV NODE_ENV=production

RUN addgroup --system --gid 1001 nodejs
RUN adduser --system --uid 1001 nextjs

# Copy built application
COPY --from=builder /app/public ./public
COPY --from=builder /app/.next/standalone ./
COPY --from=builder /app/.next/static ./.next/static
COPY --from=builder /app/bin ./bin

# Ensure Tectonic is executable
RUN chmod +x ./bin/tectonic

USER nextjs

EXPOSE 3000

ENV PORT=3000
ENV HOSTNAME="0.0.0.0"

CMD ["node", "server.js"]

Update next.config.ts

Enable standalone output for Docker:

next.config.ts

const nextConfig: NextConfig = {
  output: 'standalone',
  pageExtensions: ["js", "jsx", "md", "mdx", "ts", "tsx"],
  // ... rest of config
};

Create .dockerignore

.dockerignore

node_modules
.next
.git
.env.local
.vercel
npm-debug.log
yarn-error.log
pnpm-debug.log

Build Docker image

docker build -t typeset .

Run container

docker run -p 3000:3000 \
  -e NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY=pk_live_... \
  -e CLERK_SECRET_KEY=sk_live_... \
  -e LIVEBLOCKS_SECRET_KEY=sk_... \
  -e NEXT_PUBLIC_LIVEBLOCKS_PUBLIC_KEY=pk_... \
  -e OPENAI_API_KEY=sk-proj-... \
  typeset

Or use an environment file:

docker run -p 3000:3000 --env-file .env.production typeset

Docker Compose

For easier container management:

docker-compose.yml

version: '3.8'

services:
  typeset:
    build: .
    ports:
      - "3000:3000"
    env_file:
      - .env.production
    restart: unless-stopped
    volumes:
      - /tmp/tectonic-cache:/tmp/cache
    environment:
      - NODE_ENV=production

Run with:

docker-compose up -d

Deploy Docker to cloud platforms

# Push to Amazon ECR
aws ecr get-login-password --region us-east-1 | \
  docker login --username AWS --password-stdin <account>.dkr.ecr.us-east-1.amazonaws.com

docker tag typeset:latest <account>.dkr.ecr.us-east-1.amazonaws.com/typeset:latest
docker push <account>.dkr.ecr.us-east-1.amazonaws.com/typeset:latest

# Deploy to ECS (configure task definition with environment variables)

Deploy to traditional Node.js server

For deployment on a VPS or dedicated server:

Build the application

pnpm build

Copy files to server

Transfer these files to your server:

.next/ - Built application
public/ - Static assets
bin/ - Tectonic binary
package.json - Dependencies
node_modules/ - Or run pnpm install --prod on server

Set environment variables

Create /etc/typeset/.env.production:

NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY=pk_live_...
CLERK_SECRET_KEY=sk_live_...
LIVEBLOCKS_SECRET_KEY=sk_...
NEXT_PUBLIC_LIVEBLOCKS_PUBLIC_KEY=pk_...
OPENAI_API_KEY=sk-proj-...

Create systemd service

Create /etc/systemd/system/typeset.service:

[Unit]
Description=Typeset LaTeX Editor
After=network.target

[Service]
Type=simple
User=typeset
WorkingDirectory=/var/www/typeset
EnvironmentFile=/etc/typeset/.env.production
ExecStart=/usr/bin/node /var/www/typeset/.next/standalone/server.js
Restart=always

[Install]
WantedBy=multi-user.target

Enable and start:

sudo systemctl enable typeset
sudo systemctl start typeset

Configure Nginx reverse proxy

Create /etc/nginx/sites-available/typeset:

server {
    listen 80;
    server_name your-domain.com;
    
    # Redirect to HTTPS
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    server_name your-domain.com;
    
    ssl_certificate /etc/letsencrypt/live/your-domain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/your-domain.com/privkey.pem;
    
    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
    
    # WebSocket support for Liveblocks
    location /_liveblocks/ {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "Upgrade";
        proxy_set_header Host $host;
    }
}

Enable the site:

sudo ln -s /etc/nginx/sites-available/typeset /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

Production checklist

Before going live, verify:

Scaling considerations

Horizontal scaling

For high-traffic deployments: Vercel Vercel automatically scales serverless functions. No additional configuration needed. Docker/Kubernetes Scale horizontally with multiple containers:

# Kubernetes deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: typeset
spec:
  replicas: 3
  selector:
    matchLabels:
      app: typeset
  template:
    metadata:
      labels:
        app: typeset
    spec:
      containers:
      - name: typeset
        image: typeset:latest
        ports:
        - containerPort: 3000
        env:
        - name: CLERK_SECRET_KEY
          valueFrom:
            secretKeyRef:
              name: typeset-secrets
              key: clerk-secret

Performance optimization

LaTeX package caching Share Tectonic cache across instances:

# Mount shared volume for cache
docker run -v /mnt/shared-cache:/tmp/cache typeset

Static asset CDN Configure CDN for public/ and .next/static/:

next.config.ts

const nextConfig: NextConfig = {
  assetPrefix: process.env.CDN_URL || '',
  // ...
};

Database optimization If using a database (Neon, Supabase, etc.):

Use connection pooling
Enable read replicas for queries
Implement caching with Redis

Troubleshooting

Build fails on Vercel

Check build logs in Vercel dashboard
Verify all dependencies are in package.json
Ensure Node.js version matches (20.x)
Check for TypeScript errors: pnpm tsc --noEmit

Function timeout errors

Upgrade to Vercel Pro for longer function execution
Optimize LaTeX compilation (remove unnecessary packages)
Implement compilation caching
Pre-warm Tectonic cache with common packages

Tectonic binary not found

Verify binary exists in bin/tectonic
Check file permissions: chmod +x bin/tectonic
Ensure binary is committed to Git
Verify platform matches (Linux x86_64)

Collaboration not working

Check Liveblocks API key is correct
Verify WebSocket connections are allowed (check firewall)
Test /api/liveblocks-auth endpoint
Check browser console for errors

High memory usage

Monitor LaTeX package cache size
Implement cache cleanup for old packages
Limit concurrent compilations
Use Vercel Pro for larger memory limits

Next steps

After deployment:

Monitor application performance and errors
Set up automated backups (if using database)
Configure CI/CD for automatic deployments
Implement rate limiting for API routes
Set up staging environment for testing

Join the Typeset community for deployment support and best practices.

Setup

Advanced

Deployment options

Deploy to Vercel

Vercel deployment via GitHub

Vercel configuration

Tectonic binary on Vercel

Deploy with Docker

Docker Compose

Deploy Docker to cloud platforms

Deploy to traditional Node.js server

Production checklist

Scaling considerations

Horizontal scaling

Performance optimization

Troubleshooting

Build fails on Vercel

Function timeout errors

Tectonic binary not found

Collaboration not working

High memory usage

Next steps

Build docs developers (and LLMs) love

Setup

Advanced

​Deployment options

​Deploy to Vercel

​Vercel deployment via GitHub

​Vercel configuration

​Tectonic binary on Vercel

​Deploy with Docker

​Docker Compose

​Deploy Docker to cloud platforms

​Deploy to traditional Node.js server

​Production checklist

​Scaling considerations

​Horizontal scaling

​Performance optimization

​Troubleshooting

​Build fails on Vercel

​Function timeout errors

​Tectonic binary not found

​Collaboration not working

​High memory usage

​Next steps

Build docs developers (and LLMs) love

Deployment options

Deploy to Vercel

Vercel deployment via GitHub

Vercel configuration

Tectonic binary on Vercel

Deploy with Docker

Docker Compose

Deploy Docker to cloud platforms

Deploy to traditional Node.js server

Production checklist

Scaling considerations

Horizontal scaling

Performance optimization

Troubleshooting

Build fails on Vercel

Function timeout errors

Tectonic binary not found

Collaboration not working

High memory usage

Next steps