Why We Chose Azure Over Vercel and Netlify for Serverless Functions
Why We Chose Azure Over Vercel and Netlify for Serverless Functions
Meta Description: Azure Functions gives 1M free requests vs Vercel’s 100k and Netlify’s 125k. Plus Key Vault integration and enterprise secrets management.
We evaluated three platforms for the Learn Labs enrollment system: Vercel, Netlify, and Azure Static Web Apps. All three are excellent. All three have generous free tiers. All three integrate serverless functions with static sites.
We chose Azure. Here’s why.
The Quick Answer
Free tier limits decided it:
- Azure Functions: 1,000,000 requests/month free
- Vercel Functions: 100,000 requests/month free
- Netlify Functions: 125,000 requests/month free
For a low-traffic enrollment system, any of them work. But Azure’s 10x advantage on free tier + native Key Vault integration made it the obvious choice for a project that will eventually scale beyond one enrollment form.
Feature Comparison
| Feature | Azure Static Web Apps | Vercel | Netlify |
|---|---|---|---|
| Free Function Calls | 1M/month | 100k/month | 125k/month |
| Function Timeout | 10 min (Dedicated plan) | 10s (Hobby), 60s (Pro) | 10s (Free), 26s (Pro) |
| Function Memory | 1.5 GB | 1 GB | 1 GB |
| Build Minutes | Unlimited | 6,000/month | 300/month |
| Bandwidth | 100 GB/month | 100 GB/month | 100 GB/month |
| Custom Domains | Unlimited (free) | Unlimited (free) | 1 free (Pro: unlimited) |
| Environment Variables | Yes | Yes | Yes |
| Secrets Management | Key Vault (native) | External only | External only |
| CI/CD | GitHub Actions (auto) | Git integration | Git integration |
| Staging Environments | Preview deployments | Preview deployments | Branch deploys |
| Logs/Monitoring | Application Insights | Vercel Analytics | Netlify Analytics |
| Framework Support | All static | All static | All static |
| Edge Locations | Global CDN | Edge Network | Edge Network |
Why Azure Won
1. Free Tier Math
Our Expected Usage:
- Enrollment submissions: 150/month (optimistic first year)
- Key Vault operations: 450/month (3 secrets × 150 enrollments)
- Function executions: 150/month
Headroom:
- Azure: 0.015% of free tier used
- Vercel: 0.15% of free tier used
- Netlify: 0.12% of free tier used
When We’d Hit Limits:
- Azure: After 1,000,000 enrollments/month (never)
- Vercel: After 100,000 enrollments/month (years away)
- Netlify: After 125,000 enrollments/month (years away)
For this project specifically, all three would work. But we’re building more than one enrollment form. We’ll add:
- API endpoints for course progress tracking
- Webhook handlers for GitHub events
- Scheduled functions for email digests
- Integration testing endpoints
Azure’s 10x free tier advantage means we don’t think about function call quotas for years.
2. Key Vault Integration
This was the real differentiator. Azure Key Vault integrates natively with Azure Functions via Managed Identity. No credentials in code. No API keys to rotate. No environment variables to secure.
Azure Managed Identity:
// No credentials needed - Managed Identity handles auth
const credential = new DefaultAzureCredential();
const client = new SecretClient(keyVaultUrl, credential);
const secret = await client.getSecret("airtable-api-key");Vercel/Netlify Equivalent:
// Store API keys as environment variables
const apiKey = process.env.AIRTABLE_API_KEY;
// Or integrate external secrets manager (Doppler, Infisical, etc.)Benefits of Key Vault:
- Expiration tracking and alerts (30 days before expiry)
- Audit logs (who accessed which secret when)
- Version history (rollback if needed)
- Centralized rotation (update once, all apps get new version)
- Tagging for organization (project, service, environment)
- Soft-delete protection (30-day recovery window)
Vercel and Netlify support environment variables fine. But when you need enterprise-grade secrets management, you integrate external tools (Doppler, Infisical, HashiCorp Vault). Azure has it built in.
Cost:
- Key Vault: 10,000 operations/month free
- External secrets manager: $0-$10/month depending on service
For a single project, environment variables are fine. For multiple projects with rotating secrets, shared credentials across services, and compliance requirements, Key Vault saves hours of setup and ongoing management.
3. GitHub Actions Integration
All three platforms integrate with GitHub. But Azure Static Web Apps creates a complete GitHub Actions workflow automatically during resource creation.
What Azure Auto-Configures:
- Build workflow (runs on push to main)
- Preview deployments (runs on pull requests)
- Azure SWA deployment action
- Secrets for deployment token
- Environment variables sync
We didn’t write a single line of GitHub Actions YAML. Azure did it.
Vercel and Netlify: Both have excellent Git integration via their own platforms. They auto-deploy on push. But if you want custom build steps, testing, or multi-stage deployments, you’re writing GitHub Actions workflows yourself.
For our use case (standard Astro build → deploy), all three work equally well. But for complex CI/CD pipelines with testing, staging environments, and approval gates, Azure’s GitHub Actions foundation gives more control.
4. Function Timeout
This didn’t matter for enrollment (sub-second response times), but it matters for future features:
Timeouts:
- Azure: 10 minutes (Dedicated plan), 5 minutes (Consumption plan)
- Vercel: 10 seconds (Hobby), 60 seconds (Pro $20/seat/month)
- Netlify: 10 seconds (Free), 26 seconds (Pro $19/month)
Future Use Cases:
- Batch processing enrollments → 2-3 minutes
- Generating certificates from templates → 30-60 seconds
- Syncing data from external APIs → 1-2 minutes
- Running test suites → 3-5 minutes
Azure’s longer timeout means we don’t hit artificial limits as features expand.
5. Build Minutes
Build Limits:
- Azure: Unlimited
- Vercel: 6,000 minutes/month (Hobby)
- Netlify: 300 minutes/month (Free)
Our Astro blog builds take ~2 minutes per deployment. If we deploy 10 times per day (active development), that’s:
- 600 minutes/month (10 deployments/day × 2 min × 30 days)
Azure: ✅ No limit Vercel: ✅ Well within 6,000 limit Netlify: ⚠️ Would hit 300 limit in 15 days
Netlify’s Pro plan ($19/month) gives 25,000 build minutes, which is plenty. But Azure’s unlimited builds mean we never think about it.
Decision Matrix
Choose Azure if:
- You’re building multiple serverless functions (use that 1M free tier)
- You need enterprise secrets management (Key Vault)
- You want centralized secret rotation across projects
- You prefer GitHub Actions for CI/CD
- You’re already in Azure ecosystem (easier integration)
- You need longer function timeouts (5-10 min)
Choose Vercel if:
- You’re using Next.js (Vercel built it, integration is seamless)
- You want the simplest possible deployment (Git push = done)
- You prioritize edge performance (Vercel’s CDN is excellent)
- You want built-in analytics and monitoring
- You don’t need Key Vault-level secrets management
Choose Netlify if:
- You need advanced redirect rules and header management
- You want branch-based staging environments
- You use Netlify Forms, Identity, or other Netlify services
- You prioritize developer experience (Netlify’s DX is excellent)
- 125k function calls/month is enough
What We’d Choose for Other Projects
Next.js blog with API routes: → Vercel. Native Next.js integration, excellent edge performance, simple deployment.
Marketing site with form submissions: → Netlify. Built-in form handling, spam protection, identity management.
Multi-service platform with shared secrets: → Azure. Key Vault for secrets, 1M function calls, longer timeouts, GitHub Actions for complex CI/CD.
Simple portfolio or docs site: → Any of them. They’re all excellent for static sites.
Cost at Scale
What happens when we exceed free tiers?
Azure Functions Pricing (After 1M requests):
- $0.20 per million executions
- $0.000016/GB-s compute
- Example: 2M executions/month = $0.20-0.40/month
Vercel Pricing (Pro Plan):
- $20/seat/month
- 1M function invocations included
- Then $0.50 per additional 1M
- Example: 2M executions/month = $20/month (includes other features)
Netlify Pricing (Pro Plan):
- $19/month
- 2M function invocations included
- Then $25 per 1M
- Example: 3M executions/month = $44/month
At scale, Azure is 50-100x cheaper on compute alone. But Vercel and Netlify include analytics, team features, and support in those prices. You’re not just paying for compute.
The Real Reason We Chose Azure
We’re building for enterprise clients. Many already use Azure. Many have compliance requirements that demand Key Vault-level secrets management. Many need audit logs and access policies.
Starting with Azure means:
- No migration later when requirements change
- Patterns we establish now scale to paid projects
- Secrets management done right from day one
- 10x free tier headroom for experimentation
If Learn Labs was a side project with no enterprise aspirations, we’d probably use Vercel (best DX) or Netlify (excellent form handling). But for a system that needs to scale and integrate with enterprise infrastructure, Azure was the right choice.
Caveats
Learning Curve: Azure Portal is complex. There’s a reason Vercel and Netlify abstract it away. If you want to focus on building product (not infrastructure), Vercel or Netlify will get you shipping faster.
Vendor Lock-in: Key Vault and Managed Identity are Azure-specific. Migrating to another platform means rewriting secrets management. With Vercel/Netlify + environment variables, you’re more portable.
Overkill for Simple Projects: If you’re building a portfolio site or simple blog, Azure is overkill. Use Vercel or Netlify. Deployment takes 60 seconds, no infrastructure to think about.
Takeaway
All three platforms are excellent. The “best” choice depends on your project:
Vercel: Best DX, excellent for Next.js, perfect for product-focused teams Netlify: Best for marketing sites, built-in forms, excellent redirect management Azure: Best for enterprise, secrets management, multi-service platforms, scale
We chose Azure for the 1M free function calls, native Key Vault integration, and enterprise-ready patterns. For Learn Labs specifically, it’s the right foundation.
Your project might be different. Choose based on your constraints, not ours.
Related: In the next post, we’ll dive into the technical decisions we made to avoid technical debt—like choosing Key Vault from day one instead of environment variables.
Disclaimer: Pricing and features accurate as of January 2026. Check official documentation for current limits and pricing.