Migrate from Vercel to Azion

A platform migration usually begins long before the first project is redeployed or the first production domain is moved. Teams migrating from Vercel to Azion consolidate build, delivery, compute, AI, storage, security, and observability into a single platform and eliminating the fragmentation that grows as modern applications scale.

For teams using Vercel, this moment often appears after applications grow beyond the original deployment flow: projects with multiple environments, preview URLs, server-side functions, image optimization, redirects, rewrites, Edge Config data, Blob storage, AI integrations, firewall rules, bot controls, analytics dashboards, and production domains. Each capability can work independently, but operating them as a single production platform requires careful governance.

For teams currently using Vercel Projects, CI/CD and Preview Deployments, Content Delivery Network, Vercel Functions, Fluid Compute, AI Cloud, AI SDK, AI Gateway, Vercel Blob, Edge Config, Vercel Firewall, Web Application Firewall, Bot Management, BotID, Advanced Deployment Protection, Domains and DNS, Observability, Speed Insights, Web Analytics, or Marketplace integrations, Azion provides equivalent capabilities through Applications, Azion CLI, Preview Deployment, Functions, AI Inference, Azion AI Client, Object Storage, KV Store, Firewall, Web Application Firewall, Bot Manager, Edge DNS, Certificate Manager, Real-Time Metrics, Real-Time Events, Data Stream, Edge Pulse, and Marketplace.

The strongest reason to migrate is not simply to replace one vendor with another. It is to consolidate deployment, delivery, compute, AI, storage, security, and observability into a unified platform designed for globally distributed applications.

How Vercel to Azion Migration Works

Traditional platform migrations often require rebuilding application delivery, reworking functions, recreating environment configuration, and moving production domains under pressure. This approach increases operational risk, extends timelines, and makes rollback harder.

The Azion migration approach preserves your application behavior while transitioning to a unified platform:

1. Incremental migration path. Start with one representative Vercel project, validate build, delivery, functions, storage, security, and observability on Azion, then expand to additional projects.

2. Preserved application logic. Routes, redirects, rewrites, headers, environment variables, server-side functions, object files, configuration data, and security policies map to Azion Applications, Rules Engine, Functions, Object Storage, KV Store, Firewall, and observability products with focused changes.

3. Unified platform model. Instead of managing build, runtime, storage, security, analytics, and observability across separate product surfaces, Azion brings these capabilities together with consistent APIs, Console workflows, and deployment patterns.

Feature Mapping

The following table provides a comprehensive mapping of Vercel products and configuration areas to their Azion equivalents. A dash (-) indicates that Azion does not currently offer a direct equivalent.

Migration Strategy

The migration is organized around Azion’s four product categories, allowing teams to plan and execute each layer independently:

• Build: migrate projects, build settings, production and preview deployments, CDN behavior, redirects, rewrites, headers, image optimization, functions, Fluid Compute patterns, and AI application logic.
• Secure: migrate domains, DNS, TLS certificates, firewall rules, WAF policies, bot controls, DDoS posture, deployment access rules, and SSO dependencies.
• Store: migrate Blob files and Edge Config data to Object Storage and KV Store.
• Observe: migrate observability dashboards, real-user monitoring, analytics, function logs, event investigation, and data export workflows.

Build

The Build category covers project setup, deployment, delivery configuration, routing, runtime behavior, Functions, image optimization, and AI workloads. Start here to recreate the application behavior users see before moving security, data, and observability layers.

1. Project Setup on Azion

The first step brings your Vercel project into Azion in a way that feels familiar to teams that deploy modern web applications from Git. If you have used Vercel projects, production deployments, preview deployments, and framework presets, you already understand the pattern: connect a repository, define build settings, deploy output, and validate a generated URL.

Azion follows a similar workflow but consolidates application delivery, Functions, rules, security, storage, and observability in the same platform context.

Key Differences

Connect Your Repository

1. Open Azion Console.
2. Click + Create > Import from GitHub.
3. Authorize the Azion GitHub App.
4. Select the repository you want to migrate.

Configure Your Build

Azion auto-detects your framework and configures build settings. Override the detected preset in azion.config.js:

import { defineConfig } from 'azion'

export default defineConfig({
name: 'my-vercel-migration',
preset: 'nextjs', // Override auto-detection if needed
})

Deploy and Verify

Deploy from the Azion Console or CLI. Your temporary Azion URL follows this pattern:

https://xxxxxxxxxx.map.azionedge.net/

Validate the deployment before moving production domains:

curl -I https://xxxxxxxxxx.map.azionedge.net/
curl https://xxxxxxxxxx.map.azionedge.net/api/health

Reference documentation

• Applications
• Applications first steps
• Azion CLI overview
• Import an existing project from GitHub

2. Converting Build and Deployment Configuration

A migration can appear successful when the build passes but fail later when runtime behavior, environment variables, redirects, cache, or image optimization differs from Vercel. Review project configuration carefully instead of treating the migration as a simple command replacement.

CLI Quick Reference

Configuration Inventory

Before recreating the project in Azion, inventory:

• Vercel projects, teams, production deployments, and preview deployments
• Build commands, output directories, framework presets, and install commands
• vercel.json, framework config, middleware, and route definitions
• Environment variables across production, preview, and development
• API routes, server actions, serverless functions, and Fluid Compute workloads
• Redirects, rewrites, headers, cache behavior, and image optimization settings
• Domains, DNS records, nameservers, and certificate status
• Blob stores, Edge Config stores, feature flags, and experiments
• Firewall rules, WAF controls, bot protections, deployment access controls, and SSO dependencies
• Observability dashboards, analytics, alerting, log workflows, and Marketplace integrations

Reference documentation

• Azion CLI overview
• azion.config.js reference
• azion deploy command
• Azion Preview Deployment

3. Migrating Environment Variables

Environment variables contain API keys, database credentials, authentication secrets, third-party endpoints, AI provider tokens, feature flags, and environment-specific settings. Migrating them incorrectly causes runtime failures even when deployment succeeds.

Key Differences

Evaluate Your Variables

Before changing code, identify every variable in:

• Vercel project environment settings
• Vercel CLI-managed environment variables
• Framework .env files used for local development
• AI provider keys and model gateway settings
• Blob tokens and storage credentials
• Edge Config IDs, tokens, and keys
• CI/CD environment settings
• Runtime configuration in source code

Create Variables in Azion

curl -X POST 'https://api.azionapi.net/variables' --header 'Accept: application/json; version=3' --header 'Authorization: Token [TOKEN VALUE]' --header 'Content-Type: application/json' --data '{
"key": "AI_API_KEY",
"value": "key-value"
}'

Update Your Code

// Before: Vercel / Node.js
const apiKey = process.env.API_KEY;
const aiApiKey = process.env.AI_API_KEY;

// After: Azion Functions
const apiKey = Azion.env.get('API_KEY');
const aiApiKey = Azion.env.get('AI_API_KEY');

Reference documentation

• Environment Variables
• Working with variables
• Functions Instances

4. Migrating CDN Routing, Redirects, Rewrites, and Headers

Vercel routing behavior can come from framework routes, middleware, vercel.json, project settings, and CDN behavior. Azion Applications and Rules Engine provide equivalent controls for routing, redirects, rewrites, headers, origin selection, cache behavior, and request or response manipulation.

Key Differences

Redirect Migration Example

{
"redirects": [
  {
    "source": "/old-blog/:path*",
    "destination": "/blog/:path*",
    "permanent": true
  }
]
}

# After: Azion Rules Engine
Criteria: ${uri} matches ^/old-blog/(.*)$
Behavior: Redirect To (301): /blog/%{capture[1]}

Header Migration Example

import type { AzionConfig } from 'azion/config';

const config: AzionConfig = {
applications: [{
  name: 'my-app',
  rules: {
    response: [{
      name: 'Security Headers',
      active: true,
      criteria: [{
        variable: 'uri',
        conditional: 'if',
        operator: 'starts_with',
        argument: '/'
      }],
      behavior: {
        addResponseHeader: [
          'X-Frame-Options: SAMEORIGIN',
          'X-Content-Type-Options: nosniff'
        ]
      }
    }]
  }
}]
};

export default config;

Migration Checklist

• Convert Vercel route patterns to Rules Engine criteria and regex.
• Move simple redirects to Rules Engine.
• Move simple response headers to response rules.
• Use Functions for dynamic rewrites, authentication, signed URLs, or external lookups.
• Validate trailing slash behavior, locale prefixes, and canonical paths.
• Compare cache headers and SEO-sensitive redirects before cutover.

Reference documentation

• Applications
• Rules Engine for Applications
• Connectors
• Functions

5. Migrating Vercel Functions and Fluid Compute to Functions

Vercel Functions and Fluid Compute often contain the most business-critical application logic: API routes, authentication, server actions, AI orchestration, personalization, webhooks, and backend integrations. Azion Functions provide distributed JavaScript execution for equivalent workloads.

Key Differences

Update Function Signature

// Before: Vercel API route style
export default async function handler(req, res) {
const body = req.body;

res.status(200).json({
  message: 'Hello',
  data: body
});
}

// After: Azion Functions
export default {
async fetch(request) {
  const body = await request.json();

  return new Response(JSON.stringify({ message: 'Hello', data: body }), {
    status: 200,
    headers: { 'Content-Type': 'application/json' }
  });
}
};

Route Migration Example

// Before: Vercel file route
// app/api/users/[id]/route.ts or pages/api/users/[id].ts

// After: Azion Rules Engine routes to a Function
import { defineConfig } from 'azion'

export default defineConfig({
applications: [{
  name: 'vercel-api-migration',
  rules: {
    request: [{
      name: 'GET /api/users/:id',
      criteria: [
        { variable: 'uri', operator: 'matches_regex', argument: '^/api/users/([^/]+)$' },
        { variable: 'request_method', operator: 'equals', argument: 'GET' }
      ],
      behavior: { runFunction: 'get-user' }
    }]
  }
}]
})

Reference documentation

• Functions
• Functions Instances
• Runtime APIs
• JavaScript Runtime APIs reference

6. Migrating Cache and Dynamic Delivery Behavior

Vercel projects can combine CDN caching, framework-level cache settings, dynamic rendering, static generation, and route-level behavior. Azion provides Cache Settings, Rules Engine, Tiered Cache, and Real-Time Purge to control how content is stored and invalidated.

Key Differences

Configuration Steps

curl -X PATCH 'https://api.azion.com/v4/workspace/applications/{application_id}/cache_settings/{cache_setting_id}' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data '{
  "name": "dynamic-cache",
  "browser_cache": {
    "ttl": 300
  },
  "modules": {
    "cache": {
      "ttl": 3600
    },
    "tiered_cache": {
      "enabled": true
    }
  }
}'

Purge Example

curl -X POST 'https://api.azion.com/v4/workspace/purge/wildcard' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data '{
  "items": ["https://www.example.com/products/*"],
  "layer": "cache"
}'

Reference documentation

• Cache
• Cache Settings
• Tiered Cache
• Real-Time Purge

7. Migrating Image Optimization

Vercel Image Optimization transforms and delivers optimized images for web applications. Azion Image Processor transforms, optimizes, and delivers images from distributed locations using URL parameters and application configuration.

Key Differences

Configuration Steps

curl -X PATCH 'https://api.azionapi.net/v4/workspace/applications/{application_id}' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data '{
  "modules": {
    "image_processor": {
      "enabled": true
    }
  }
}'

URL Format Comparison

# Vercel framework-generated image URL pattern varies by framework
/_next/image?url=%2Fhero.jpg&w=1200&q=75

# Azion Image Processor
/hero.jpg?ims=1200x

Transformation Parameters

Reference documentation

• Image Processor
• How to process images
• Object Storage

8. Migrating AI Workloads

Vercel AI Cloud, AI SDK, and AI Gateway patterns usually combine application code, model calls, streaming responses, tool calls, provider routing, usage tracking, and observability. On Azion, AI workloads can combine AI Inference, Functions, Azion AI Client, Cache, Real-Time Events, and Data Stream depending on the use case.

Key Differences

Function Integration Example

export default {
async fetch(request) {
  const prompt = await request.text();

  const response = await fetch('https://ai-provider.example.com/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer ' + Azion.env.get('AI_API_KEY')
    },
    body: JSON.stringify({ prompt })
  });

  return response;
}
};

Migration Checklist

• Inventory models, providers, routes, and fallback behavior.
• Move provider credentials to Azion variables.
• Recreate AI API routes with Functions.
• Decide whether inference runs through AI Inference or external providers.
• Rebuild observability with Real-Time Events, Real-Time Metrics, and Data Stream.
• Validate streaming responses, timeouts, and error handling.

Reference documentation

• AI Inference
• AI Inference models
• Azion AI Client
• Functions

Secure

The Secure category covers domains, DNS, certificates, firewall rules, WAF protections, bot controls, DDoS protection, deployment access controls, and account access. Plan these migrations as controlled cutovers because they affect how users reach your application and how traffic is protected in production.

1. Migrating Custom Domains, DNS, and Certificates

Custom domain migration is one of the most sensitive parts of any platform transition. It affects users, SEO, brand trust, and production availability. Plan domain migration as a controlled cutover, not a last-minute DNS change.

Migration Strategies

Create the Certificate

Create your SSL/TLS certificate before pointing your domain to Azion. This ensures users can access the application securely over HTTPS when the domain starts resolving to the new infrastructure.

Azion provides free Let’s Encrypt certificates with automatic renewal.

Configure the Domain

Create a workload in Azion Console and associate your custom domain. See Workloads Documentation.

Point the Domain to Azion

www CNAME xxxxxxxxxx.map.azionedge.net

ns1.aziondns.net
ns2.aziondns.com
ns3.aziondns.org

Verify Propagation

dig www.yourdomain.com CNAME +short
curl -I https://www.yourdomain.com/

Reference documentation

• Workloads
• Create an Azion custom domain
• Edge DNS
• Certificate Manager

2. Migrating Vercel Firewall and WAF Controls

Vercel Firewall and WAF controls protect applications from unwanted traffic, abusive patterns, application-layer attacks, and suspicious automated requests. Azion Firewall, Web Application Firewall, Rules Engine for Firewall, Network Lists, and Functions for Firewall provide equivalent controls.

Key Differences

Migration Steps

curl -X POST 'https://api.azion.com/v4/workspace/wafs' --header 'Accept: application/json' --header 'Authorization: Token [TOKEN]' --header 'Content-Type: application/json' --data '{
  "active": true,
  "name": "Vercel Migration WAF",
  "product_version": "1.0",
  "engine_settings": {
    "engine_version": "2021-Q3",
    "type": "score",
    "attributes": {
      "rulesets": [1],
      "thresholds": [
        { "threat": "sql_injection", "sensitivity": "medium" }
      ]
    }
  }
}'

Rule Migration Example

# Vercel-style intent
Block requests to /admin unless the client IP is in an approved network.

# Azion criteria
Variable: ${uri}
Operator: matches
Argument: /admin

AND

Variable: ${remote_addr}
Operator: does not match
Argument: 10.0.0.0/8

Behavior: Deny (403)

Reference documentation

• Firewall
• Web Application Firewall
• Rules Engine for Firewall
• Network Lists

3. Migrating DDoS Protection, Bot Controls, and Deployment Protection

Vercel Platform Security, Bot Management, BotID, and Advanced Deployment Protection combine infrastructure protection, bot mitigation, and access controls for deployments. Azion provides DDoS Protection, Network Shield, Bot Manager, Bot Manager Lite, Firewall rules, and Network Lists for equivalent outcomes.

Capability Mapping

Deployment Access Example

Criteria: ${uri} starts with /preview/
AND
Criteria: ${remote_addr} does not match 10.0.0.0/8

Behavior: Deny (403)

Reference documentation

• DDoS Protection
• Network Shield
• Bot Manager
• Bot Manager Lite
• Rules Engine for Firewall

4. Migrating SAML Single Sign-On

If your Vercel organization uses SAML SSO, document identity provider settings, group membership, user access, and operational runbooks before migration. Azion supports Single Sign-On for centralized account access.

Migration Checklist

• Inventory identity providers and SAML metadata.
• Map Vercel team roles to Azion account and team permissions.
• Configure SSO in Azion before broad user migration.
• Validate break-glass administrator access.
• Review MFA, user session timeout, and access policies.

Reference documentation

• Single Sign-On
• Teams Permissions
• Multi-Factor Authentication

Store

The Store category covers object and key-value data. Migrate Blob files and Edge Config data with attention to consistency, access patterns, object naming, permissions, caching, and application compatibility.

1. Migrating Vercel Blob to Object Storage

Vercel Blob stores application files such as images, documents, videos, and user uploads. Azion Object Storage is S3-compatible and can be used as an origin for Applications.

Key Differences

Update Configuration

// Before: Vercel Blob pattern
import { put } from '@vercel/blob';

const blob = await put('avatar.png', file, {
access: 'public'
});

// After: S3-compatible Object Storage client
import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';

const client = new S3Client({
region: 'us-east-005',
endpoint: 'https://s3.us-east-005.azionstorage.net',
credentials: {
  accessKeyId: Azion.env.get('AZION_ACCESS_KEY'),
  secretAccessKey: Azion.env.get('AZION_SECRET_KEY')
}
});

await client.send(new PutObjectCommand({
Bucket: 'my-bucket',
Key: 'avatar.png',
Body: file
}));

Migrate Data with S3-Compatible Tools

Use tools such as s3cmd, rclone, or AWS CLI to move objects:

Reference documentation

• Object Storage
• How to access Object Storage using the S3 protocol
• Create and modify a bucket
• Upload and download objects
• Use a bucket as origin

2. Migrating Edge Config to KV Store

Vercel Edge Config is often used for feature flags, experiments, redirects, configuration, and frequently read application data. Azion KV Store provides distributed key-value storage accessible from Functions.

Key Differences

API Comparison

// Before: Vercel Edge Config
import { get } from '@vercel/edge-config';

const checkoutEnabled = await get('feature:checkout');

// After: Azion KV Store
const kv = await Azion.KV.open('my-namespace');

const checkoutEnabled = await kv.get('feature:checkout');

Create a KV Store Namespace

curl -X POST 'https://api.azionapi.net/v4/workspace/kv/namespaces' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data '{
  "name": "vercel-migration-kv"
}'

Migration Checklist

• Export keys, values, metadata, and environment-specific values from Vercel.
• Preserve key prefixes and naming conventions where possible.
• Document default behavior for missing keys.
• Validate value encoding and JSON serialization.
• Test read paths before moving production traffic.
• Rebuild feature flag and experiment workflows that rely on Vercel-specific tooling.

Reference documentation

• KV Store
• How to manage KV Store with Functions
• KV Store API
• Functions

Observe

The Observe category covers metrics, events, analytics, real-user monitoring, logs, and external data streams. Migrating observability ensures you keep production visibility, troubleshooting capability, and compliance reporting after cutover.

1. Migrating Observability to Real-Time Metrics and Real-Time Events

Vercel Observability provides visibility into application traffic, functions, external API calls, performance, errors, and usage. Azion Real-Time Metrics and Real-Time Events provide dashboards, event investigation, and GraphQL access for production troubleshooting.

Key Differences

Available Metrics

Azion Real-Time Metrics tracks:

• Request metrics: total requests, requests by status code, requests by HTTP method
• Performance metrics: response time, upstream header time, origin response time
• Bandwidth metrics: data transferred and data saved by cache
• Cache metrics: hit ratio, miss ratio, expired objects
• Error metrics: 4xx errors, 5xx errors, origin errors

Access Real-Time Events

query HttpEvents {
workloadEvents(
  limit: 100,
  filter: {
    tsRange: {begin: "2024-01-01T00:00:00", end: "2024-01-01T01:00:00"}
  }
) {
  ts
  remoteAddress
  requestUri
  status
  upstreamResponseTime
}
}

Reference documentation

• Real-Time Metrics
• Real-Time Events
• Investigate requests with the GraphQL API
• Understand Real-Time Events logs

2. Migrating Speed Insights and Web Analytics

Vercel Speed Insights and Web Analytics provide real-user performance and site analytics. Azion Edge Pulse and Real-Time Metrics can support equivalent monitoring and performance analysis workflows.

Key Differences

Migration Checklist

• Inventory current Core Web Vitals, page-level reports, and analytics dashboards.
• Decide which dashboards move to Edge Pulse, Real-Time Metrics, or external BI tools.
• Recreate custom event tracking if needed.
• Validate privacy and consent requirements.
• Compare post-cutover user experience metrics against Vercel baselines.

Reference documentation

• Edge Pulse
• Real-Time Metrics
• Real-Time Events

3. Migrating Data Export and Marketplace Integrations

Vercel Marketplace and observability integrations often connect production applications to databases, CMSs, analytics, logging, messaging, commerce, security, and AI providers. Azion Marketplace and Data Stream provide integration paths for applications and observability data.

Configure Data Stream

curl -X POST 'https://api.azion.com/v4/workspace/stream/streams' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data '{
  "name": "Vercel Migration Log Stream",
  "source": {
    "type": "applications"
  },
  "template_id": 12345,
  "endpoint": {
    "type": "s3",
    "name": "my-s3-endpoint",
    "bucket": "my-logs-bucket",
    "region": "us-east-1",
    "access_key": "YOUR_ACCESS_KEY",
    "secret_key": "YOUR_SECRET_KEY"
  },
  "active": true
}'

Supported Destinations

Data Stream supports multiple destination patterns:

• Cloud Storage: Amazon S3, Azure Blob Storage, Azion Object Storage
• Monitoring: Datadog, Splunk, Elasticsearch, Azure Monitor
• Streaming: AWS Kinesis Data Firehose, Apache Kafka
• Analytics: Google BigQuery
• Security: IBM QRadar
• Custom: HTTP Webhook, Standard HTTP/HTTPS POST

Reference documentation

• Data Stream
• Data Stream first steps
• Use Data Stream
• Marketplace

Troubleshooting

Common Issues

Key Advantages After Migration

Migrating from Vercel to Azion is strongest when the team treats the first cutover as a repeatable migration pattern. The immediate goal is continuity: users keep reaching the same domains, critical routes continue working, security controls remain active, and observability is ready before traffic moves.

The larger value comes after migration, when teams operate build, delivery, compute, AI, storage, security, and observability in one platform model.

With Azion, teams can build and run applications on globally distributed infrastructure while combining compute, delivery, AI, storage, security, and observability capabilities in one environment. This reduces the fragmentation that often appears when modern applications depend on many separate services and configuration patterns.

Next Steps

After your migration is complete:

• Review Real-Time Metrics to monitor application performance.
• Set up Real-Time Events for production visibility.
• Configure Web Application Firewall for production security.
• Review the individual feature guides for advanced configuration.

Get Started with a Small Project

The best way to begin is not with the most complex Vercel project in your portfolio. Start with a project that is meaningful enough to validate the migration path, but small enough to move quickly and safely.

Choose a project that includes representative pieces of your architecture: one production-like domain, a few routes, redirects, headers, maybe one function, one Blob dependency, one Edge Config dependency, and one analytics workflow. Use that project to validate the workflow, document the process, and identify internal patterns your team can reuse.

From there, expand gradually. Migrate more complex routing. Move additional functions. Bring over storage and configuration data. Add observability. Review security rules. Then prepare production cutovers with greater confidence.

Recommended Next Steps

• Create your free Azion account
• Read the Applications documentation
• Explore the Azion CLI
• Review Data Stream

Need Help?

Get help from the Azion Support team, or join our Discord community to see how others are using Azion.