TIMEWELL
Solutions
Free ConsultationContact Us
TIMEWELL

Unleashing organizational potential with AI

ISO/IEC 27001 (ISMS) certification mark (SGS / ISMS-AC)

ISO/IEC 27001:2022 certified Certificate No. JP26/00000255 Scope: Planning, development and operation of SaaS products utilizing AI technology

Services

  • ZEROCK
  • TRAFEED
  • TIMEWELL BASE
  • WARP
  • WARP 1Day
  • WARP NEXT Corporate
  • WARP BASIC
  • WARP ENTRE
  • Alumni Salon
  • WARP for Schools
  • Alumni Ventures
  • FDE
  • AI Consulting
  • EMC GLOBAL

Company

  • About Us
  • Team
  • Why TIMEWELL
  • News
  • Contact
  • Free Consultation

Content

  • Insights
  • Knowledge Base
  • Case Studies
  • Whitepapers
  • Events
  • Solutions
  • AI Readiness Check
  • ROI Calculator

Legal

  • Privacy Policy
  • Manual Creator Extension
  • WARP Terms of Service
  • WARP NEXT School Rules
  • Legal Notice
  • Security
  • Anti-Social Policy
  • ZEROCK Terms of Service
  • TIMEWELL BASE Terms of Service

Newsletter

Get the latest AI and DX insights delivered weekly

Your email will only be used for newsletter delivery.

© 2026 株式会社TIMEWELL All rights reserved.

Contact Us
HomeColumnsWARPNo More Fear With Vercel — A Practical Website Security Guide for Vibe Coding Beginners
WARP

No More Fear With Vercel — A Practical Website Security Guide for Vibe Coding Beginners

Published2026-02-25Updated2026-11-06Ryuta Hamamoto
VercelSecurityvibe codingNext.jsWARP

"Vibe coding" has become a common phrase lately — using AI to build websites and apps even without deep programming experience.

No More Fear With Vercel — A Practical Website Security Guide for Vibe Coding Beginners
Share

Hello, this is Hamamoto from TIMEWELL. Today I want to cover something on the technical side.

"Vibe coding" has become a common phrase lately — using AI to build websites and apps even without deep programming experience. The combination of Next.js and Vercel has been spreading rapidly, especially among individual developers, thanks to how easy and high-performance it is.

But the thing that tends to get pushed to the back burner when building becomes this accessible is security. "It's a personal project, it's a small site" — let your guard down and it will cost you. When a data breach or site defacement happens, the developer bears the responsibility. User trust, once lost, takes an enormous amount of time to rebuild.

This article covers the security measures you absolutely need to have in place when building with Vercel — with concrete code examples. I've focused on the points that, from building client sites myself, I've come to feel are the non-negotiable minimum.

The short answer first. Vercel gives you encrypted transport and DDoS mitigation from the start, but form spam protection, environment variables, who can see your previews, and dependency updates are yours to decide. This article walks through those in order. It does not describe attack procedures.

On 6 November 2026 I re-checked the specifications against Vercel's official documentation. These points have changed since the first edition in February 20261.

Item First edition Current official documentation
Managed rulesets Read as if SQL injection and XSS rules were one click away on every plan The OWASP core ruleset is Enterprise-only. Bot Protection and AI Bots are the two available on all plans
Country blocking Presented as part of IP Blocking Regional restrictions are written as custom rules; IP Blocking is for IP addresses and CIDR ranges
Attack Challenge Mode Described as challenging only suspicious traffic Now called Attack Mode. When on, every visitor except known bots such as search engines faces a security challenge. Free on all plans
Environment variable types No distinction Config and Secret. A Secret cannot be read back after saving
BotID setup Server-side checkBotId() only Browser-side setup (initBotId) is also required; the result is read from isBot
Vulnerable Next.js Not covered New deployments containing a version with a published vulnerability fail by default on Vercel

Why Security Matters in the First Place

"My site is small, so attackers won't bother targeting it." This thinking is the most dangerous.

The majority of modern cyberattacks don't target specific sites. Programs automatically scan the internet for vulnerable sites and launch attacks automatically. Site size is irrelevant — anything published on the internet is a potential target.

The threats individual developers are most likely to face:

Threat Type What Happens
Site defacement Your homepage gets rewritten. Phishing links may be embedded.
Form spam and bot attacks Your contact form floods with meaningless text and ads, burying legitimate inquiries
API key leakage An API key written into source code gets exposed and exploited by third parties — sometimes resulting in massive bills
DDoS attack Overwhelming traffic takes down the server, making the site unreachable

The direct damage is bad enough, but secondary damage is serious too. A defaced site destroys visitor trust. Dealing with spam consumes time you need for actual work. A personal data breach can lead to liability claims.

Security is a technical topic — but it's equally a business risk topic.

What Vercel Protects You With Out of the Box

Security might sound intimidating, but using Vercel already means a substantial amount of protection is handled automatically. Start by understanding these built-in benefits.

HTTPS/SSL Automation

Whether your site URL starts with https:// — that "s" stands for Secure, meaning communication between the browser and server is encrypted with SSL/TLS. It prevents third parties from eavesdropping or tampering with data, is a basic requirement, and affects Google search rankings.

Normally, obtaining and renewing SSL certificates takes effort. With Vercel, simply configuring a custom domain triggers free SSL certificate issuance and automatic renewal. You don't need to think about certificate management at all. This is a quietly valuable feature.

DDoS Protection

A DDoS attack overwhelms a target server with traffic from large numbers of computers, taking down the service. Even personal project sites can be targeted.

Vercel provides platform-wide DDoS protection as standard across all plans. Its globally distributed edge network detects abnormal traffic and blocks it automatically. No special configuration needed.

Data Encryption at Rest

Data stored on Vercel's infrastructure is encrypted with AES-256 — the encryption standard used by the US government. Even if data were physically stolen, decryption would be extremely difficult.

This infrastructure-level protection is what lets us focus on application development with confidence. But beyond this point, you enter the territory of "things that won't protect you unless you configure them yourself."

Looking for AI training and consulting?

Learn about WARP training programs and consulting services in our materials.

Book a Free ConsultationDownload Resources

Mastering Vercel Firewall

In addition to Vercel's standard DDoS protection, the Vercel Firewall — specifically its WAF (Web Application Firewall) capabilities — lets you build a second layer of defense.

If the standard DDoS protection is an army guarding the national border, the WAF is a security guard standing at the door to your building. You decide who to let in and who to turn away, with fine-grained rules of your own.

WAF custom rules and IP blocking are available on all plans. Open your project and choose Firewall in the left sidebar. Four capabilities to know about:

IP Blocking

Completely blocks access from specific IP addresses. If you're seeing your access logs and the same IP is making repeated login attempts, you can block that IP by name.

To restrict by country or region, write a condition as a custom rule rather than using IP blocking; Vercel's documentation points to custom rules for geographic restrictions2. It helps when your service is Japan-focused but you see large volumes of overseas spam. Treat country-level blocking as a way to cut mechanical scanning and spam, not as your main defence: attackers route through servers in Japan and the US as well.

Custom Rules

More flexible access control than IP blocking. Define "if this condition is met, take this action" rules of your own choosing.

For example: restrict access to the admin panel (/admin, etc.) to only your home or office IP. Block access from specific User-Agents. Custom rules are where these fine-grained adjustments become possible.

Do not start a rule on "deny". Run it as "log" first and check recent traffic for unintended matches, which is the procedure the documentation recommends. It avoids locking out your own IP or genuine enquiries. Rate limiting is configured as a kind of custom rule too.

Managed Rule Sets

"Creating rules myself sounds hard" — don't worry. Vercel's security team has created and maintains a pre-built rule collection.

Three are available today3.

  • OWASP core ruleset: predefined rules based on standards such as the OWASP Top Ten, covering well-known patterns like SQL injection and XSS. Enterprise plans only
  • Bot Protection ruleset: all plans. Off by default; when enabled, it serves a JavaScript challenge to traffic unlikely to be a browser
  • AI Bots ruleset: all plans. Lets you set AI training crawlers and user-triggered AI assistants separately to "log" or "deny"

The first edition made SQL-injection protection sound like a one-click item on every plan; that applies to Enterprise. On Pro and Hobby, rely on input validation and parameterised queries in your application, supplemented by WAF custom rules.

Attack Mode (formerly Attack Challenge Mode)

Something to switch on temporarily when your site is under a targeted attack. While it is on, visitors must pass a security challenge to see the site. Known legitimate bots, such as search engines, webhooks and Vercel cron jobs, pass without one4.

It is free on all plans, and traffic it blocks does not count towards usage. Vercel's DDoS mitigation already runs automatically, so this is an extra measure for when you are being singled out, not a permanent setting. Standalone APIs and automated integrations that cannot solve a challenge may be blocked. You can toggle it under Firewall → Bot Management.

Start by opening the dashboard and browsing what settings are available. Hands-on, it's simpler than it looks.

Three Weapons for Protecting Forms from Spam

Once you publish a website, your contact form becoming a spam target is almost unavoidable. Bots flood it with ads and meaningless strings.

In the past, the standard approach was "I'm not a robot" checkboxes or distorted image CAPTCHAs — but those are nothing but friction for users. Having someone abandon a form mid-completion because it became a nuisance is completely self-defeating.

Now, the mainstream approach is to filter bots intelligently on the backend without requiring any user action. Three tools available in a Next.js + Vercel environment:

Honeypot

True to its name, a "honey trap" for bots. The mechanism is simple: plant an invisible dummy input field in the form.

Humans don't fill in what they can't see. But bots programmatically search for all fields in a form and dutifully try to fill them all. So if the invisible field has a value, "this is a bot" is the conclusion.

An old-school technique, but easy to implement and effective against simple bots. This is the first line of defense you want in place from the start.

Add a dummy field to the form component and use CSS to push it off-screen so it's invisible.

// components/ContactForm.jsx

<form action={...}>
  {/* Normal input fields */}

  {/* Honeypot: hidden with CSS */}
  <div className="hidden" aria-hidden="true">
    <label htmlFor="honeypot">Leave this field empty</label>
    <input type="text" id="honeypot" name="honeypot" tabIndex={-1} autoComplete="off" />
  </div>

  <button type="submit">Submit</button>
</form>

/* global.css */
.hidden {
  position: absolute;
  left: -5000px;
  opacity: 0;
}

On the server side, check whether this field has a value:

// app/actions.js
'use server';

export async function submitForm(formData) {
  // Honeypot check
  if (formData.get('honeypot')) {
    // Identified as bot. Return as if successful without doing anything
    return { success: true };
  }

  // Continue processing as a human request
}

The key: when identified as a bot, don't return an error. Returning an error tells the bot side that this defense is in place.

Vercel BotID

Honeypot handles simple bots, but smarter bots that interpret CSS and only fill visible fields also exist. That's where Vercel's proprietary BotID comes in.

BotID is an "invisible CAPTCHA" that requires absolutely no action from users. Running in the background, it uses machine learning to analyze thousands of signals — mouse movements, keyboard patterns, browser environment — and determines human vs. bot.

Two levels are available5. Basic verifies that the browser solved the challenge correctly and is free on all plans. Deep Analysis uses machine learning over many signals and can counter advanced bots driven by Playwright or Puppeteer. It is available on Pro and Enterprise; on Pro each checkBotId() call costs $1 per 1,000. Page views, and requests that do not call the function, are not charged.

Setup has two parts, browser and server. The first edition showed only the server side, but if you do not register the protected paths in the browser, checkBotId() cannot classify requests correctly. On Next.js 15.3 and later, put this in instrumentation-client.ts:

// instrumentation-client.ts
import { initBotId } from 'botid/client/core';

initBotId({
  protect: [
    { path: '/api/contact', method: 'POST' },
  ],
});

On the server, read isBot from the return value of checkBotId():

// app/api/contact/route.ts
import { checkBotId } from 'botid/server';
import { NextResponse } from 'next/server';

export async function POST(request) {
  const verification = await checkBotId();

  if (verification.isBot) {
    return NextResponse.json({ error: 'Access denied' }, { status: 403 });
  }

  // Continue processing as a human request
}

The package is botid (not the @vercel/bot-id shown in the first edition). In local development it always returns isBot: false unless you configure it otherwise. Before going live, submit the form for real on a preview deployment and confirm that genuine submissions are not rejected. Calling a protected path directly with curl is rejected in production; test by sending a fetch from a page in your own app.

Google reCAPTCHA v3

The third option is Google's reCAPTCHA v3 — completely different from v2's checkbox approach, and v3 also requires zero user interaction.

reCAPTCHA v3 analyzes user behavior as they navigate the site and assigns a score from 0.0 (likely a bot) to 1.0 (likely human) indicating how human-like the request is. Retrieve this score at form submission and set a threshold like "below 0.5, treat as a bot" — a flexible approach.

The google-recaptcha-v3 library makes implementation convenient.

First, obtain a site key and secret key from Google and set them as environment variables. NEXT_PUBLIC_RECAPTCHA_V3_SITE_KEY is used on the client side; RECAPTCHA_V3_SECRET_KEY on the server side.

On the frontend, obtain a token when the form is submitted:

// components/ContactForm.jsx
import { GoogleReCaptchaProvider, useGoogleReCaptcha } from 'google-recaptcha-v3';

const FormComponent = () => {
  const { executeRecaptcha } = useGoogleReCaptcha();

  const handleSubmit = async (event) => {
    event.preventDefault();
    if (!executeRecaptcha) return;

    const token = await executeRecaptcha('contactForm');
    // Pass form data and token to the Server Action
  };

  return <form onSubmit={handleSubmit}>...</form>;
}

const ContactForm = () => (
  <GoogleReCaptchaProvider reCaptchaKey={process.env.NEXT_PUBLIC_RECAPTCHA_V3_SITE_KEY}>
    <FormComponent />
  </GoogleReCaptchaProvider>
);

On the backend, send the received token to Google's API and verify the score:

// app/actions.js
'use server';

export async function submitForm(formData, token) {
  const response = await fetch(
    `https://www.google.com/recaptcha/api/siteverify?secret=${process.env.RECAPTCHA_V3_SECRET_KEY}&response=${token}`,
    { method: 'POST' }
  );
  const data = await response.json();

  if (!data.success || data.score < 0.5) {
    return { success: false, message: 'Bot detection failed.' };
  }

  // Continue processing as a human request
}

Personally, I consider the combination of all three the ideal setup. Honeypot filters crude bots, BotID catches mid-level bots, and reCAPTCHA v3 handles sophisticated ones. Defense in depth, and none of it is visible to visitors.

Verification after rollout is not optional, though. The most painful failure in form protection is blocking genuine enquiries. Start with a lenient score threshold and tune it by watching how many submissions are blocked and how many get through. Also avoid giving a honeypot field a meaningful name such as "website": password managers can autofill it and cause genuine submissions to be rejected. A meaningless name is safer.

Preview Access and Dependency Updates

Two things vibe coding tends to overlook are the non-production URLs and the packages an AI adds.

Preview URLs are not necessarily closed to the public by default. Vercel Authentication protects preview and production deployments behind a team login and is available on every plan at no extra cost. Password Protection costs $20 per month per project on Pro and is not available on Hobby6. Assume that screens you do not want outsiders to see are placed behind one of these.

As for dependencies, an AI sometimes suggests a package name that does not exist, and a malicious package may already have been registered under that name. Check the publisher and release date before running npm install; that habit is the most effective defence.

The same goes for the framework itself. In December 2025 Vercel began failing, by default, new deployments that contain a Next.js version vulnerable to CVE-2025-664787. The premise is to move to a patched version wherever you host. If a deployment suddenly fails, suspect the Next.js version first. An override environment variable exists, but it keeps a vulnerable build in production, so use it only for temporary isolation.

Where Do You Hide API Keys? Proper Environment Variable Management

Whenever vibe coding involves integrating external services, API keys inevitably appear. Databases, AI services, email sending services — all accessed using an API key, a "secret key" for that service.

If that API key leaks, third parties can impersonate you and misuse the service. Data theft, floods of requests driving up enormous bills — the most common individual developer security incidents involve exactly this kind of accidental leakage.

Hard-Coding Into Source Code Is Absolutely Not Okay

The worst thing you can do is write API keys directly into code. This is called hard-coding.

// Never do this
const apiKey = 'sk_xxxxxxxxxxxxxxxxxxxxxxxxxxxx';

// Push this code to GitHub and... the API key is publicly visible to the entire world

Even if your GitHub repository is private, hard-coding should be avoided whenever there's any possibility of sharing code with others. Manage API keys using environment variables.

How to Set Up Environment Variables

An environment variable is a configuration value stored in the application's execution environment, separate from the code itself. The code references the "name" of the environment variable, not the API key itself.

During local development, create a .env.local file at the project root and write your API keys there. Keeping .env files away from AI coding tools is covered concretely in Keeping .env away from Claude Code. With vibe coding, also think about the routes by which a key can end up in an AI chat history or logs.

# .env.local
DATABASE_URL="postgres://..."
OPENAI_API_KEY="sk_..."

The one thing you absolutely cannot forget: exclude .env.local from Git management. Verify that .env.local is in the .gitignore file. If you created the Next.js project with create-next-app, it's included by default — but get into the habit of visually confirming this.

In Vercel's production environment, open your project's Settings → Environment Variables and register the same names and values there. This lets you handle API keys safely in both local and production environments without changing any code.

When you add a variable, choose Config or Secret for each one8. A Config value can be read back by authorised members; a Secret is write-only after saving. API keys and database connection strings should normally be Secrets. Environment variables are encrypted at rest.

One easily missed point: changing an environment variable does not affect deployments that are already running. It applies from the next deployment. If you rotated a key but the old value is still in use, redeploy. And for a leaked key, revoke it at the issuer; redeploying is not enough.

The NEXT_PUBLIC_ Prefix Trap

This is the most dangerous pitfall.

In Next.js, environment variables beginning with NEXT_PUBLIC_ are embedded into client-side JavaScript at build time and become visible to anyone through the browser developer tools. Changing the value after the build does not alter JavaScript that has already been served.

This is designed for values that are meant to be public — like a Google Analytics tracking ID — but the number of people who don't know this and accidentally add NEXT_PUBLIC_ to API keys never seems to go down.

Variable Type Visible To Example Uses
DATABASE_URL Server side only Database connection strings, API keys, anything that must stay secret
NEXT_PUBLIC_GA_ID Published to the browser too Google Analytics ID and other information that's safe to be public

Never add NEXT_PUBLIC_ to anything that must remain secret. This is a rule to internalize at the very start of vibe coding.

Also readSlopsquatting Has Arrived: 20% of AI-Recommended Packages Don't Exist | The New Front of npm/PyPI Supply Chain Attacks

Taking Defense One Step Further With Security Headers

On top of all of the above, for one more layer of protection: security headers. These are HTTP headers added to server responses that activate browser security features to prevent specific attacks.

In Next.js, writing in next.config.js adds headers to every page's response:

// next.config.js

const securityHeaders = [
  {
    key: 'X-Content-Type-Options',
    value: 'nosniff'
  },
  {
    key: 'X-Frame-Options',
    value: 'SAMEORIGIN'
  },
  {
    key: 'Strict-Transport-Security',
    value: 'max-age=63072000; includeSubDomains; preload'
  }
];

module.exports = {
  async headers() {
    return [
      {
        source: '/:path*',
        headers: securityHeaders,
      },
    ];
  },
};

A brief explanation of what each header protects:

Content-Security-Policy (CSP)

A powerful defense against XSS attacks. Lets you strictly specify which domains can serve resources the page is allowed to load. Scripts from domains not on the allowlist get blocked by the browser — so even if a malicious script gets injected, it can't execute.

A note: starting with CSP set too restrictively can accidentally block your own site's Google Fonts or Analytics scripts. A realistic approach is to start in report-only mode, confirm there are no unintended blocks, and then tighten gradually.

X-Frame-Options

Prevents your site from being embedded in another site's iframe. Protection against "clickjacking" — where a malicious site covers your site with a transparent iframe and tricks users into clicking buttons they didn't mean to. Setting SAMEORIGIN allows embedding only from within your own site.

X-Content-Type-Options

Setting nosniff prevents browsers from ignoring server instructions and guessing a file's format on their own (MIME sniffing). Guards against attacks that would cause a text file to be mistakenly executed as a script.

Strict-Transport-Security (HSTS)

Instructs browsers to force HTTPS connections for any user who has previously accessed the site via HTTPS. Even if a user accidentally navigates to http://, unencrypted communication doesn't happen.

These headers work automatically once set, making them a high-value-per-effort measure.

Pre-Launch Security Checklist

Everything covered in this article, organized as a final check before publishing your site. Work through it one by one to send your website into the world with confidence.

Vercel Firewall / WAF

  • Have you enabled the managed rulesets available to you (Bot Protection, AI Bots; OWASP core too on Enterprise), after checking them in log mode? (Firewall → Rules)
  • Have you blocked suspicious IPs, and written any country or region restriction as a custom rule?
  • Have you restricted access to specific paths (like the admin panel) by IP? (Custom Rules)
  • Did you check each new rule in log mode before switching it to deny?

Form Spam and Bot Protection

  • Have you implemented a Honeypot (invisible input field) in the form?
  • Does the server-side logic abort processing when the Honeypot field has a value?
  • Have you added BotID, registered the protected paths with initBotId() in the browser, and read isBot from checkBotId() on the server?
  • Have you submitted the form for real on a preview deployment to confirm genuine submissions are not rejected?
  • Have you implemented Google reCAPTCHA v3 and verified the score server-side?

Sensitive Information Management

  • Have you avoided writing API keys or database connection strings directly into source code?
  • Are all sensitive values managed in the .env.local file?
  • Have you confirmed that .env.local is in the .gitignore file?
  • Have you set all production environment variables in the Vercel dashboard, with API keys as Secrets?
  • Did you redeploy after changing environment variables?
  • Have you reviewed all environment variables to confirm no secret API keys have the NEXT_PUBLIC_ prefix?

Security Headers

  • Have you configured security headers (X-Content-Type-Options, X-Frame-Options, HSTS) in next.config.js?
  • Have you considered introducing Content-Security-Policy (CSP), at least in report-only mode?

Previews and Dependency Management

  • Have you put previews you do not want public behind Vercel Authentication or similar?
  • Are you keeping Next.js on a patched version?
  • Have you run npm audit or yarn audit to check for known vulnerabilities in your packages?
  • Have you addressed any discovered vulnerabilities through package updates or other means?

I hope this checklist serves as a useful reference in your development process.

Security Is Not "Set It and Forget It"

This article has covered security in a Vercel environment from six angles.

Vercel's standard protections, Firewall (WAF) access control, layered bot defense with Honeypot / BotID / reCAPTCHA v3, sensitive information management with environment variables, and browser-level defense with security headers. None of these are difficult to configure on their own.

That said — honestly — security configuration is not something you do once and finish. New vulnerabilities are discovered every day, and attack methods keep evolving. The right posture is to regularly check the official documentation of the frameworks and services you use and keep your knowledge current.

If you have concerns about technology selection or security architecture, please consider TIMEWELL's WARP program. Former DX and data strategy specialists from major enterprises provide monthly support for building and operating sites using modern tech stacks including Vercel + Next.js — covering everything from security design through implementation.

There's no need to aim for perfection from day one. Start by putting in the basic measures covered in this article one by one, and your site's security will improve in a concrete, measurable way. A secure website is the foundation of trust with your users. Start with what you can do today, and enjoy vibe coding with confidence.

References

Footnotes

  1. Vercel Security overview, Vercel Firewall and Security & Compliance Measures (Vercel documentation). That DDoS mitigation applies to all plans without configuration, that the WAF is available on all plans, and that data at rest is encrypted with AES-256 and data in transit with HTTPS/TLS 1.3, come from these pages. Checked 6 November 2026 ↩

  2. WAF IP Blocking and WAF Custom Rules (Vercel documentation). That IP Blocking is for IP addresses and CIDR ranges, that geographic restrictions use custom rules, and the log-first procedure come from these pages. Checked 6 November 2026 ↩

  3. WAF Managed Rulesets (Vercel documentation). That the OWASP core ruleset is Enterprise-only and that Bot Protection and AI Bots are available on all plans (off by default) come from this page. Checked 6 November 2026 ↩

  4. Attack Mode (Vercel documentation). That it is free on all plans, lets known legitimate bots through, and that blocked traffic is not counted towards usage come from this page. Checked 6 November 2026 ↩

  5. BotID and Get Started with BotID (Vercel documentation). The difference between Basic and Deep Analysis, Deep Analysis on Pro and Enterprise at $1 per 1,000 calls, the browser-side initBotId and server-side checkBotId() setup, and isBot: false in local development come from these pages. Checked 6 November 2026 ↩

  6. Access Control (Vercel documentation). That Vercel Authentication is available on all plans at no extra cost, and that Password Protection is $20 per month per project on Pro and unavailable on Hobby, come from this page. Checked 6 November 2026 ↩

  7. New deployments of vulnerable Next.js applications are now blocked by default (Vercel Changelog, 5 December 2025). That new deployments containing a Next.js version vulnerable to CVE-2025-66478 fail automatically, and that upgrading to a patched version is recommended, come from this page. Checked 6 November 2026 ↩

  8. Environment variables (Vercel documentation). The Config and Secret types, encryption at rest, changes applying only to new deployments, and NEXT_PUBLIC_ values being inlined at build time come from this page. Checked 6 November 2026 ↩

This article was produced with the help of AI. A human verified the primary sources and edited the text before publication.

Read next

Articles that answer the question you are likely to have next.

  1. 1How to Stop Claude Code from Reading .env Files: Deny Rules, Sandbox, and Hooks (2026)How to keep .env secrets away from Claude Code, checked against the October 2026 docs: deny rules that work, the reads they miss, and how the sandbox and hooks close the gap.
  2. 2Slopsquatting Has Arrived: 20% of AI-Recommended Packages Don't Exist | The New Front of npm/PyPI Supply Chain Attacks“I asked Claude Code for a React state management library. It suggested react-pretty-state. npm install worked fine. Behavior was clean.
  3. 3Running Business Apps in Your Own Cloud Tenant: Access, Data Location, and Personal DataIf you are dropping a SaaS product and building the business app yourself, my view is that it usually runs better inside your own cloud environment, your own tenant. The fifth and final article in this series covers how that differs from multi-tenant SaaS, what you gain in identity, access, data integration, and audit logs, why "who can touch the data" rather than where it sits decides whether Japan's APPI treats a vendor as an entrusted party, why choosing a Tokyo region does not remove the duty to understand foreign rules, and how operational responsibility shifts to you. It draws on NIST, AWS, the Japanese Personal Information Protection Commission's Q&A and the 2026 APPI amendment, and ISO/IEC 27001.

Considering AI adoption for your organization?

Our DX and data strategy experts will design the optimal AI adoption plan for your business. First consultation is free.

Book a Free Consultation
Book a Free Consultation45-minute online sessionDownload ResourcesProduct brochures & whitepapers

Share this article if you found it useful

Share

Newsletter

Get the latest AI and DX insights delivered weekly

Your email will only be used for newsletter delivery.

Related Knowledge Base

AI Adoption Roadmap

Solutions

AI Adoption & DX SupportEnd-to-end support from strategy to adoption

Learn More About WARP

Discover the features and case studies for WARP.

Contact UsView WARP Details

Related Articles

Claude Code's Team Development Era Begins — A Beginner's Deep Dive into /simplify and /batch in v2.1.63

Claude Code's Team Development Era Begins — A Beginner's Deep Dive into /simplify and /batch in v2.1.63

Now that AI writing code has become the norm, "AI as a tool for individual productivity" is hardly novel anymore.

2026-03-02
How to Build a Business in the AI Era | When "Building It" Got Cheap, What Became Valuable?

How to Build a Business in the AI Era | When "Building It" Got Cheap, What Became Valuable?

In an era when you can build a prototype in a weekend for almost nothing with Vibe Coding, where did the value of a business go?

2026-07-19
University Education Reform for the AI Era — Immersion in Problem-Solving and Developing the Next Generation of AI Agent Leaders

University Education Reform for the AI Era — Immersion in Problem-Solving and Developing the Next Generation of AI Agent Leaders

As AI redefines every structure in society, how should university education change? Today I want to share my honest thinking about what that future looks like.

2026-03-07
AI-Powered App Development for Non-Engineers — The Complete Practical Guide From V0 to Cursor

AI-Powered App Development for Non-Engineers — The Complete Practical Guide From V0 to Cursor

AI-Powered App Development for Non-Engineers. This TIMEWELL guide covers DX, WARP, AI with practical takeaways for teams.

2026-01-21
"AI × Cursor" — How to Get 10 Years of Skills in 10 Minutes: Writing Requirements Documents

"AI × Cursor" — How to Get 10 Years of Skills in 10 Minutes: Writing Requirements Documents

"AI × Cursor". This TIMEWELL article explains the context and practical takeaways for professionals.

2026-01-21
Claude Code × SOC 2 / ISO 27001 Implementation Guide: Designing Controls That Reconcile AI Adoption with Certification Maintenance (2026 Edition)

Claude Code × SOC 2 / ISO 27001 Implementation Guide: Designing Controls That Reconcile AI Adoption with Certification Maintenance (2026 Edition)

An implementation guide for teams that want to deploy Claude Code at the enterprise level without breaking their SOC 2 Type II or ISO/IEC 27001:2022 certifications.

2026-04-25