Migrate from Vercel to Azion | Complete migration guide for modern applications

Learn how to migrate from Vercel to Azion with less operational risk. Migrate Vercel projects, production deployments, preview deployments, CDN configuration, Functions, Fluid Compute, AI integrations, Blob, Edge Config, Firewall, WAF, bot controls, domains, DNS, analytics, and observability workflows to Azion Applications, Functions, AI Inference, Object Storage, KV Store, Firewall, Web Application Firewall, Edge DNS, Certificate Manager, Real-Time Metrics, Real-Time Events, Data Stream, and Edge Pulse.

View as Markdown

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, 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:

Incremental migration path. Start with one representative Vercel project, validate build, delivery, functions, storage, security, and observability on Azion, then expand to additional projects.
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.
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.

Vercel Product or Feature	Description	Azion Equivalent
Projects	Main application resource for build, deployment, environment, domains, and runtime settings.	Applications
Production Deployments	Production builds promoted to customer-facing domains.	Applications + Azion CLI
CI/CD and Preview Deployments	Git-integrated build and deployment platform with automatic preview environments.	Applications + Azion CLI + Preview Deployment
Content Delivery Network	Global delivery for caching, routing, compression, TLS, redirects, and rewrites.	Applications + Cache + Rules Engine
Redirects and rewrites	Path and host routing configured in project settings, framework config, or `vercel.json`.	Rules Engine for Applications
Headers	Custom request or response headers configured for routes.	Rules Engine for Applications
Image Optimization	On-demand image transformation and delivery.	Image Processor
Microfrontends	Compose independently deployed frontend projects under centralized routing.	Applications + Rules Engine
Vercel Functions	Managed server-side functions for APIs, dynamic pages, and backend integrations.	Functions for Applications
Fluid Compute	Server-side compute model designed to improve concurrency and reduce cold starts for dynamic workloads.	Functions
Environment Variables	Project-level values for production, preview, and development environments.	Environment Variables + Functions Instances
AI Cloud	Platform for building and operating AI applications.	AI Inference + Functions + Applications
AI SDK	TypeScript toolkit for building AI-powered applications, agents, streaming interfaces, and tool-calling experiences.	AI Inference + Azion AI Client + Azion Lib
AI Gateway	Unified endpoint for model access, routing, fallbacks, retries, usage monitoring, and observability.	AI Inference + Functions + Real-Time Events
Vercel Blob	Managed object storage for files, uploads, images, documents, and videos.	Object Storage
Edge Config	Globally replicated low-latency data store for feature flags, experiments, redirects, and configuration.	KV Store
Platform Security	DDoS mitigation, TLS, platform firewalling, access controls, and security monitoring.	Firewall + DDoS Protection + Network Shield
Vercel Firewall	Traffic rules, IP blocks, rate limits, redirects, challenges, Attack Mode, and exceptions.	Firewall + Rules Engine for Firewall + Network Lists
Web Application Firewall	Managed and custom protection against application-layer attacks.	Web Application Firewall
Bot Management	Automated traffic detection, mitigation, challenge, allow, and block controls.	Bot Manager + Bot Manager Lite
BotID	Invisible bot verification for sensitive actions.	Bot Manager
Advanced Deployment Protection	Access controls for deployment URLs using authentication, trusted IPs, passwords, or bypasses.	Firewall + Rules Engine for Firewall + Network Lists
SAML Single Sign-On	Centralized workforce authentication through a SAML-compatible identity provider.	Single Sign-On
Domains and DNS	Custom domains, DNS records, nameservers, and SSL certificate automation.	Workloads + Edge DNS + Certificate Manager
Observability	Monitoring for traffic, builds, functions, external API calls, performance, errors, and usage.	Real-Time Metrics + Real-Time Events + Data Stream
Speed Insights	Real-user performance monitoring based on Core Web Vitals.	Edge Pulse + Real-Time Metrics
Web Analytics	Website analytics for page views, visitors, referrers, demographics, custom events, and feature usage.	Edge Pulse + Real-Time Metrics
Observability Plus	Extended observability retention, metrics, request data, queries, notebooks, monitoring, and alerts.	Real-Time Metrics + Real-Time Events + Data Stream
Web Analytics Plus	Longer analytics reporting windows and additional attribution data.	Edge Pulse + Real-Time Metrics
Vercel Marketplace	Integration catalog for databases, storage, auth, AI, observability, CMS, commerce, messaging, and security.	Marketplace
Vercel CLI	Command-line workflow for projects, deployments, logs, domains, and environment variables.	Azion CLI

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.

If you do not need near-zero downtime, you can migrate in phases with maintenance windows. This allows stopping writes during each migration step without requiring parallel data synchronization.

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

Aspect	Vercel	Azion
Primary resource	Project	Application + Workload
Config file	`vercel.json`, framework config, project settings	`azion.config.js` and Console configuration
Preview workflow	Preview deployments	Azion Preview Deployment and CLI workflows
Routing and behavior	Framework routes, `vercel.json`, CDN config	Applications, Rules Engine, Functions
Observability	Observability, Speed Insights, Web Analytics	Real-Time Metrics, Real-Time Events, Data Stream, Edge Pulse

Connect Your Repository

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

Keep the first deployment intentionally small. Do not try to migrate every Vercel project, function, domain, Blob store, Edge Config value, firewall policy, analytics dashboard, and AI integration at once. Start by proving one representative application can build and run on Azion.

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

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

Task	Vercel CLI	Azion CLI
Install	`npm i -g vercel`	`curl -fsSL https://cli.azion.app/install.sh \| bash`
Login	`vercel login`	`azion login`
Local dev	`vercel dev`	`azion dev`
Deploy preview	`vercel`	`azion deploy` and Preview Deployment workflows
Deploy production	`vercel --prod`	`azion deploy`
View logs	`vercel logs`	`azion logs`
Rollback	Vercel deployment rollback	`azion rollback`

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

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

Aspect	Vercel	Azion
Access	`process.env.VARIABLE`	`Azion.env.get('VARIABLE')`
Scopes	Production, Preview, Development	Function instance and environment context
Secrets	Project environment variables	Variables in Functions Instances
Configuration data	Environment variables and Edge Config	Variables and KV Store

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

Access Azion Console.
Navigate to Build > Variables.
Click Add Variable.
Enter the variable name and value.
Click Save.

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"

}

Azion manages environment variables at the Function instance level, not through a standalone variables API. Variables are configured as key-value pairs in the vars field when creating or updating a function instance. See the Functions Instances documentation for details.

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');

warning — Avoid copying secrets into local notes, tickets, chat messages, or temporary documents. Keep secrets in approved systems and limit access to processes that need them.

Reference documentation

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

Aspect	Vercel	Azion
Routing config	Framework routes and `vercel.json`	Applications + Rules Engine
Redirects	`redirects` in `vercel.json` or framework config	Rules Engine redirect behavior
Rewrites	`rewrites` in `vercel.json` or framework config	Rules Engine and Functions
Headers	`headers` in `vercel.json` or framework config	Rules Engine request/response behaviors
Origin selection	Vercel-managed project delivery	Connectors + Rules Engine

Redirect Migration Example

// Before: vercel.json

{

"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

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

Aspect	Vercel Functions / Fluid Compute	Azion Functions
Function model	Server-side function routes	Function + Function Instance
Function signature	Framework-dependent handlers	`export default { async fetch(request) {} }`
Environment access	`process.env.VARIABLE`	`Azion.env.get('VARIABLE')`
Routing	File-system or framework routing	Rules Engine + Functions
Data access	Vercel Blob, Edge Config, external services	Object Storage, KV Store, external services

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

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

Aspect	Vercel	Azion
Cache configuration	Framework cache behavior, CDN settings, headers	Cache Settings + Rules Engine
Cache key	Platform and framework behavior	Advanced Cache Key
Purge	Redeploys, cache invalidation behavior	URL, Cache Key, Wildcard purge
Stale behavior	Framework and CDN controls	Stale-while-revalidate settings
Origin reduction	Vercel-managed CDN	Tiered Cache + Origin Shield

Configuration Steps

Access Azion Console.
Edit your Application.
Navigate to Cache Settings.
Configure default cache TTL.
Enable Tiered Cache when origin load reduction is required.
Add custom cache rules through Rules Engine.

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

}

Cache settings are managed as sub-resources under applications. You must specify both the application_id and the cache_setting_id to update cache configuration.

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

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

Aspect	Vercel Image Optimization	Azion Image Processor
Transformations	Framework and platform image optimization	Resize, crop, fit, format optimization
URL format	Framework-generated image URLs	`?ims=<OPTIONS>` query parameter
Format support	Optimized image formats	WebP, AVIF, JPEG, PNG
Source	Project assets or remote images	HTTP origin or Object Storage
Delivery path	Vercel CDN	Azion Application with Image Processor

Configuration Steps

Access Azion Console.
Edit your Application.
Navigate to Image Processor settings.
Enable Image Processor.
Configure default quality and format behavior.
Validate representative image URLs before cutover.

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

Syntax	Description	Example
`?ims=WxH`	Resize to width x height	`?ims=400x300`
`?ims=Wx`	Resize to width with automatic height	`?ims=400x`
`?ims=xH`	Resize to height with automatic width	`?ims=x300`
`?ims=WxH:fill`	Crop to exact dimensions	`?ims=400x300:fill`
`?ims=WxH:fit`	Fit within dimensions	`?ims=400x300:fit`

Azion Image Processor automatically optimizes image format based on the client’s Accept header, serving WebP or AVIF to supported browsers.

Reference documentation

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

Aspect	Vercel AI	Azion
Model access	AI Gateway and provider integrations	AI Inference or external providers called from Functions
SDK pattern	AI SDK	Azion AI Client and standard JavaScript APIs
Streaming	Framework and SDK streaming responses	Functions with Web APIs and streaming responses
Observability	AI Gateway and Observability	Real-Time Events, Real-Time Metrics, Data Stream
Routing and fallbacks	AI Gateway	Functions with provider routing logic

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

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

Strategy	Best For	DNS Control
CNAME	Quick subdomain migration	Keep your DNS provider
Nameserver	Full DNS control and apex domains	Transfer DNS to Azion

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

Point the subdomain to the Azion-generated domain:

www CNAME xxxxxxxxxx.map.azionedge.net

This keeps your current DNS provider while routing traffic through Azion.

Configure your domain to use Azion DNS nameservers:

ns1.aziondns.net

ns2.aziondns.com

ns3.aziondns.org

This gives Azion full DNS control, required for apex domains.

Verify Propagation

dig www.yourdomain.com CNAME +short

curl -I https://www.yourdomain.com/

warning — Before switching production traffic, confirm: certificate is active, domain is associated with the correct workload, DNS records are ready, critical routes have been tested, redirects behave as expected, and monitoring is configured for post-cutover validation.

Reference documentation

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

Aspect	Vercel Firewall / WAF	Azion Firewall / WAF
Managed WAF	Vercel WAF protections	Azion WAF Rule Sets
Custom traffic rules	Firewall rules	Rules Engine for Firewall
IP controls	IP blocks and allowlists	Network Lists
Rate limiting	Firewall rate controls	Rules Engine for Firewall + Functions
Actions	Block, challenge, redirect, allow patterns	Allow, deny, drop, redirect, custom HTML, hold connection

Migration Steps

Access Azion Console.
Go to Products menu > Firewall.
Select or create a Firewall instance.
Enable WAF rule sets where needed.
Recreate custom rules in Rules Engine.
Create Network Lists for IP allowlists or blocklists.
Associate the Firewall with your workload.

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)

Run WAF changes in a monitored mode before enforcing blocks. Compare false positives, top triggered rules, bypass requirements, and application-specific exceptions before production enforcement.

Reference documentation

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

Vercel Capability	Azion Migration Path
Platform Security	DDoS Protection + Network Shield + Firewall
Bot Management	Bot Manager + Bot Manager Lite
BotID	Bot Manager and application-specific Function logic where needed
Advanced Deployment Protection	Firewall + Rules Engine + Network Lists
Trusted IPs	Network Lists
Password or authentication gates	Functions + Firewall rules

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

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

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

Aspect	Vercel Blob	Azion Object Storage
Data model	Blob objects	Buckets and objects
Access pattern	Vercel Blob SDK and URLs	S3-compatible tools, API, CLI, Runtime API
Endpoint	Vercel-managed Blob endpoints	`s3.us-east-005.azionstorage.net`
Delivery path	Vercel platform delivery	Applications + Connectors
Private files	Token and URL patterns	Bucket/object permissions and application logic

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:

Task	Command Pattern
List buckets	`s3cmd ls`
Upload object	`s3cmd put file.png s3://my-bucket/`
Download object	`s3cmd get s3://my-bucket/file.png`
Sync buckets	`s3cmd sync s3://source-bucket/ s3://dest-bucket/`

Use the S3 endpoint for object management operations. For end-user delivery, serve objects through Applications and Connectors so traffic benefits from cache, security controls, and your production domain.

Reference documentation

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

Aspect	Vercel Edge Config	Azion KV Store
Data model	Items in Edge Config stores	Namespaces with key-value pairs
Access pattern	Edge Config SDK	Functions through `Azion.KV`
Common use cases	Feature flags, experiments, redirects, config	Feature flags, experiments, redirects, config, lightweight state
Update workflow	Vercel dashboard/API	Azion Console/API and migration scripts

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

Access Azion Console.
Go to Store > KV Store.
Create a namespace for the migrated data.
Import or recreate keys using your migration script.
Update Functions to use the namespace name.

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

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

Aspect	Vercel Observability	Azion Observe
Metrics	Project, function, traffic, usage, and performance views	Real-Time Metrics dashboards and GraphQL API
Event investigation	Logs and request details	Real-Time Events datasets and GraphQL API
Retention	Plan and add-on dependent	Product and destination dependent
Export	Integration dependent	Data Stream to external destinations

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

Access Azion Console.
Go to Products menu > Real-Time Events.
Select the dataset, such as HTTP Requests or WAF.
Configure the time range and filters.
Click Search to query logs.
Click a row to inspect event details.

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

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

Aspect	Vercel Speed Insights / Web Analytics	Azion
Real-user monitoring	Speed Insights	Edge Pulse
Traffic and performance metrics	Web Analytics and Observability	Real-Time Metrics
Event investigation	Dashboard and project views	Real-Time Events
External analytics	Marketplace integrations	Data Stream and Marketplace integrations

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

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

Access Azion Console.
Go to Products menu > Data Stream.
Click + Stream.
Configure the source, such as Applications or WAF.
Select or create a template for the log format.
Choose a destination.
Configure destination credentials.
Activate the 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

Troubleshooting

Common Issues

Issue	Likely Cause	Solution
Build fails on Azion	Framework preset, install command, or output directory differs from Vercel	Check `azion.config.js`, package scripts, and build output
Environment variables not found	Variables were not configured on the Function instance	Confirm variables exist and code uses `Azion.env.get()`
Redirects or rewrites behave differently	Vercel route patterns were converted to incorrect regex	Test capture groups and verify Rules Engine criteria
API routes fail	Function signature or request parsing still assumes Vercel runtime	Rewrite handlers using `fetch(request)` and standard Web APIs
Images are not optimized	Vercel image URLs were not converted or Image Processor is disabled	Enable Image Processor and update image URL patterns
Cache behavior changed	Framework cache behavior, TTL, or cache key was not mapped	Review Cache Settings, Advanced Cache Key, and Rules Engine
Blob files missing	Object export or import was incomplete	Re-export files, verify object keys, and validate bucket permissions
Edge Config data missing	KV namespace or migration script is incomplete	Recreate keys, validate namespace names, and test default values
Firewall rules block valid users	Rule logic or IP lists differ from Vercel	Run in monitored mode, compare events, and tune criteria
Analytics gap after cutover	Vercel analytics dependencies were not replaced	Configure Edge Pulse, Real-Time Metrics, Real-Time Events, and Data Stream
Certificate not active	Domain ownership or certificate association is incomplete	Confirm certificate status and workload association before DNS cutover

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.

Area	Advantage after migration	What it means in practice
Migration strategy	Incremental migration path	Migrate one project, validate build, delivery, and security, then expand and reducing rollback risk at every step.
Platform model	Unified application platform	Build, Secure, Store, and Observe capabilities are managed through a connected platform model.
Build	Modern application deployment	Applications can be deployed from GitHub or CLI with Azion configuration.
Build	Rules-based application control	Rules Engine manages redirects, rewrites, headers, cache behavior, routing, and request/response logic.
Build	Distributed function execution	Functions replace Vercel Functions and Fluid Compute patterns for APIs, personalization, AI orchestration, and integrations.
Build	Integrated cache and image optimization	Cache, Tiered Cache, Real-Time Purge, and Image Processor are configured as part of the delivery layer.
AI	AI workloads integrated with delivery	AI Inference and Functions support model calls, routing, and application logic alongside observability.
Secure	Controlled domain and TLS cutover	Workloads, Edge DNS, and Certificate Manager can be prepared before switching production traffic.
Secure	Integrated application security	WAF, Bot Manager, Network Shield, rate limiting patterns, and Firewall rules protect workloads together.
Store	S3-compatible Object Storage	Vercel Blob workflows can be migrated using familiar S3-compatible tools and SDKs.
Store	KV for low-latency application data	Edge Config use cases can be migrated to KV Store for configuration, flags, experiments, redirects, and lightweight state.
Observe	Real-time metrics for production visibility	Real-Time Metrics provides dashboards and GraphQL access for traffic, cache, latency, and error data.
Observe	Real-time events for investigation	Real-Time Events provides detailed logs for requests, functions, WAF, DNS, image processing, and other datasets.
Observe	Data streaming to external tools	Data Stream sends logs to external destinations for SIEM, analytics, storage, and compliance workflows.

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

Need Help?

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