deploybase.eu

Yes, if your site is a static build with an optional serverless function, deploybase is designed to accept it. The site provides a dedicated migration entry point for Netlify and Vercel users that lets you bring your existing settings with you, and it connects to the same Git providers you likely already use. The main caveat is that functions are in beta and only available on paid plans, so a migration that depends on functions is not a like-for-like free move.

What carries over

deploybase's own migration path is described as "Moving from Netlify or Vercel? Bring your settings with you." That means you do not have to rebuild your configuration from scratch — the intent is to reuse what you already have.

The deployment model you get after migrating keeps the workflow most Netlify/Vercel users expect:

• Branch previews — every branch gets a preview link, so pull requests stay reviewable.
• Instant rollback — production is described as "a pointer," so rolling back means repointing rather than rebuilding.
• Git-connected deploys — every push updates the site automatically.

Supported Git providers

You connect a repository rather than uploading a build artifact, so the first check is whether your host is supported:

If your Netlify or Vercel project is already wired to one of these, the migration is mostly a matter of reconnecting the same repo.

The three ways to get a site live

Migration does not force one route. deploybase offers three:

1. Ask your AI agent — paste a setup prompt into Claude, Cursor, or any MCP client; it fetches instructions, connects itself, and asks you for one key that only a person can create. This route currently needs a Git repository.
2. Drag and drop your files — no build, no repository. Up to 250 MiB on the free plan. Create an account, start a new project, choose "Upload a folder," and drag in the folder containing your index.html.
3. Push from Git — create an account, connect your repository, and push. Code in a functions/ directory runs beside the site.

For a Netlify/Vercel migration, route 3 is the closest match to what you already do.

What the deploy actually looks like

deploybase publishes a real build log, which is useful for judging whether your own build fits. In the recorded example (a Vite/npm site with one function):

• Queued: waited 1.7 s
• Cloned the repository: 0.0 s
• Built: 13.6 s (tsc --noEmit && vite build)
• Uploaded 12 files, bundled 1 function: 7.4 s
• Live 32 seconds after push

The site landed at eu-check.sites.deploybase.eu and the function at scan-eu-check.fn.deploybase.eu. If your Netlify/Vercel build is a standard static framework build, expect a similar shape — a short queue, a clone, a framework build, an upload, then live.

What to check before you commit

• Functions are beta and paid. The example function ran on a paid plan. If your Netlify/Vercel project relies on serverless functions, confirm plan and beta status before migrating.
• Functions get their own hostname. They are not served from the same path as the site — the pattern is <name>-<site>.fn.deploybase.eu. Any hardcoded function URLs in your frontend need updating.
• Forms have a no-backend option. deploybase lists "Forms without a backend," which matters if you currently use Netlify Forms.
• Hosting is European. If your reason for migrating is data location, that is the core selling point.
• Pricing is flat, in euros. Check the pricing page for current figures rather than assuming parity with your existing plan.

A practical migration sequence

1. Create a free account.
2. Start a new project and connect the same repository you use on Netlify or Vercel.
3. Bring your build settings across using the migration entry point.
4. Push a branch first and confirm the preview link renders correctly.
5. Move any function code into functions/ and update frontend URLs to the fn.deploybase.eu hostname.
6. Point production at the branch you trust, then add your own domain.

The migration is convenient for static sites and low-risk for anyone already on Git-based deploys. The decision point is functions: if your app depends on them, treat the move as a paid, beta-stage migration rather than a drop-in replacement.

A form tool is software that lets you create, publish, and manage online forms without writing code. You drag fields onto a page, set rules for how the form behaves, and share a link or embed it in a website. When someone submits the form, the tool stores the responses and can route them to an email inbox, a spreadsheet, a database, or another app. That is the whole idea: replace paper forms and ad-hoc email threads with a structured, trackable digital version.

The sections below explain the main types of forms, the features that matter, where form tools get used, and how to pick one.

What a form tool actually does

At minimum, a form tool handles four jobs:

1. Building — assembling fields (text, email, dropdown, file upload, date, rating, signature) into a layout.
2. Publishing — generating a shareable link, an embeddable snippet, or a standalone page.
3. Collecting — receiving submissions and validating them (required fields, correct email format, file size limits).
4. Handling — storing responses, notifying someone, and passing data onward.

Anything beyond that — payments, e-signatures, workflow automation — is an add-on, not the core function.

The main types of forms people build

Most tools handle all five. The differences show up in how much logic, storage, and integration each type demands.

Features worth understanding

Drag-and-drop builder

The standard interface. You pick field types from a sidebar and arrange them visually. No HTML or CSS required, though many tools let you add custom code if you want it.

Conditional logic

This is what separates a basic form from a useful one. Conditional logic shows or hides fields based on earlier answers. Example: if a respondent selects "I have a pet," the form reveals a field for the pet's name. If they select "No," that field never appears. This keeps forms short for most people while still collecting detail from those who need it.

Validation and required fields

Validation prevents bad data. An email field rejects "abc," a number field rejects letters, and a required field blocks submission until it is filled. Good tools validate as the user types, not just on submit.

Submission handling

Where do answers go? Options typically include:

• Email notification to one or more addresses.
• Spreadsheet export (CSV, or a live connection to Google Sheets or Excel).
• Built-in dashboard with search, filtering, and export.
• Webhook or API to push data into another system.

If you need responses in a CRM, a project board, or a database, check that the tool supports that destination before committing.

File uploads and payments

File upload fields let respondents attach documents or images, usually with a size cap. Payment fields connect to a payment processor so the form can collect a fee at submission. These are common in registration and order forms.

Spam protection

Public forms attract bots. Look for CAPTCHA, honeypot fields (hidden fields bots fill in but humans do not), or rate limiting.

Where form tools get used

• Healthcare and veterinary clinics — new patient intake, appointment requests, insurance and payment information collection, post-visit feedback.
• Education — course registration, permission slips, quiz-style assessments, parent contact updates.
• Events — RSVPs, attendee registration, session sign-ups, dietary preferences.
• Small business — quote requests, job applications, customer satisfaction surveys.
• Nonprofits — volunteer sign-ups, donation pledges, grant applications.
• Internal operations — IT support tickets, expense requests, employee onboarding checklists.

The pattern is consistent: any process that currently runs on paper, PDFs, or "just email me the details" is a candidate for a form tool.

Form tools vs. website builders

These are often confused, so it helps to separate them.

A website builder creates and hosts entire pages — navigation, content, images, blog posts, and forms. A form tool focuses only on the form and its data. Many website builders include a basic form feature, but it is usually limited: few field types, no conditional logic, weak submission management.

A dedicated form tool is the better choice when you need:

• Complex logic or multi-page forms.
• Reliable storage and export of responses.
• Integrations with other software.
• Forms that live outside your website (shared by link, embedded anywhere).

A website builder's built-in form is fine for a simple contact box on a small site.

How to choose a form tool

Work through these questions in order:

1. What do you need to collect? List every field and whether it is required. This tells you which field types you cannot live without.
2. Does it need logic? If answers should change what is asked next, conditional logic is mandatory.
3. Where must the data end up? Email only, or a spreadsheet, CRM, or database? Confirm the integration exists.
4. How many responses? Some tools cap submissions or storage on lower tiers. Check the limit against your expected volume.
5. Who will build and maintain it? A non-technical user needs a clean drag-and-drop interface; a developer may prefer API access and custom code.
6. What about compliance? If you collect health, financial, or personal data, check how the tool handles encryption, data retention, and regional privacy rules. This is a general consideration, not legal advice — confirm requirements for your situation.
7. What does it cost at your scale? Pricing usually scales with features, submission volume, or number of users. Compare at the tier you would actually need, not the free plan.

A simple starting workflow

If you are building your first form, this sequence works for almost any use case:

1. Write down the single purpose of the form in one sentence.
2. List only the fields needed for that purpose. Cut anything "nice to have."
3. Group related fields into sections or pages if there are more than about ten.
4. Add conditional logic to hide irrelevant questions.
5. Set validation on email, phone, and number fields.
6. Decide where submissions go and test that destination.
7. Submit the form yourself, then check the notification, the stored response, and the export.
8. Share the link or embed it, then review responses after the first week and trim fields that nobody uses.

Bottom line

A form tool turns a question-and-answer process into a structured, trackable digital workflow. The core value is not the form itself but what happens to the data afterward — where it lands, who sees it, and how easily it can be acted on. Choose based on the fields you need, the logic required, and the destination for responses, and you will avoid most of the common mistakes.

Deploybase is a hosting platform for static sites and serverless functions that runs on European infrastructure. It is aimed at developers and teams who want to ship a site quickly — by asking an AI agent, dragging in a folder, or pushing from Git — and who care about where their data is hosted. You can start free, and pricing is listed in euros.

What you can put on it

Two kinds of things:

• Static sites — plain HTML/CSS/JS, or a built output from a framework. In the platform's own example build, a Vite site produced 12 files totalling 181.7 KB.
• Serverless functions — code placed in a functions/ directory runs alongside the site, but is served from its own hostname rather than a path on the site.

Functions are currently in beta and available on paid plans, so a free account is enough to try static hosting but not necessarily functions.

The three ways to deploy

The drag-and-drop route accepts up to 250 MiB on the free plan and needs no build step or repository. The agent route is the only one that currently requires a Git repository.

How a deploy actually behaves

Production on deploybase is a pointer, not a fixed artifact — which is what makes instant rollback possible. Each deploy produces a new build, and switching production to it (or back) is a pointer change rather than a rebuild.

The platform publishes a real build log from 26 September 2026 for a site called eu-check with one function:

• Waited 1.7 s in the queue
• Cloned the repository
• Built in 13.6 s (tsc --noEmit && vite build, 5 modules transformed)
• Uploaded 12 files and bundled 1 function in 7.4 s
• Live 32 seconds after the push

The site landed at eu-check.sites.deploybase.eu and the function at scan-eu-check.fn.deploybase.eu. That split is worth noting: the function is not at /scan on the site, it is a separate hostname under fn.deploybase.eu.

Naming and addresses

Every project gets predictable default hostnames:

• Site: my-site.sites.deploybase.eu
• Function: signup-my-site.fn.deploybase.eu

You add your own domain when you are ready, so you are not forced to configure DNS before you can see the site working.

Forms without a backend

Deploybase includes form handling, so a static page can accept submissions without you writing or hosting an endpoint. This is the usual reason a purely static site would otherwise need a function or a third-party service.

Who it fits

Deploybase is a reasonable choice if:

• You want European hosting and euro-denominated, flat pricing rather than per-seat or usage-based billing.
• You deploy static output and want branch previews and rollback without extra configuration.
• You want to drive deploys from an AI agent through MCP, or you want the lowest-friction path of dragging a folder in.
• You are moving from Netlify or Vercel and want to bring your existing settings across.

It is less suited if you need functions on a free plan right now, or if you need a full application runtime rather than static assets plus isolated functions.

Getting started

1. Create a free account.
2. Pick a path: paste the agent setup prompt into your MCP client, upload a folder, or connect a repository.
3. Push or upload — the site goes live on its sites.deploybase.eu link.
4. Add your own domain when you are ready.

For the agent route specifically, the setup instruction is to fetch and follow https://deploybase.eu/agent-setup, after which the agent connects itself and asks you for a single key that only a person can create.

You can get a site live on deploybase in three ways: ask an AI agent (Claude, Cursor, or any MCP client), drag and drop a folder, or push from Git. All three end with your site on a *.sites.deploybase.eu link, and you can attach your own domain afterward. Pick the method that matches what you already have — a folder of files, a repository, or an agent-driven workflow.

Before you start

• A free account. Every path below starts with creating one. Hosting is described as free to start, with flat pricing in euros on the pricing page.
• Your content in one of three shapes: a folder containing at least an index.html, a Git repository (GitHub, GitLab, Bitbucket, Codeberg, or Forgejo), or a project you want an agent to handle.
• A domain (optional). You can add your own domain when you're ready; it isn't required to go live.

Option 1: Drag and drop your files

Best when you have a static folder and no build step or repository.

1. Create a free account.
2. Start a new project and choose Upload a folder.
3. Drag in the folder that contains your index.html (or pick it from the file browser).
4. Your site is live at my-site.sites.deploybase.eu.

The free plan accepts uploads up to 250 MiB. No build and no repository are involved, so what you upload is what gets served.

Watch for: the folder you drag must contain index.html at its top level — dragging a parent folder that wraps your site in an extra directory level is the usual reason a page comes up empty.

Option 2: Push from Git

Best when you want every push to update the site and every branch to get its own preview link.

1. Create a free account and connect your repository.
2. Push your code.
3. Each push updates your site. Code placed in a functions/ directory runs alongside it.
4. Both go live on their own links:
   • Site: my-site.sites.deploybase.eu
   • Function: signup-my-site.fn.deploybase.eu (functions are in beta on paid plans)

A real deployment from the site's own example — a Vite site with one function, pushed on 26 September 2026 — shows what the timeline looks like: 1.7 s queued, 13.6 s build, 7.4 s to upload 12 files and bundle one function, live 32 seconds after the push. That's a small project, so treat it as a scale reference rather than a guarantee.

Watch for: functions are a beta feature on paid plans, so a free-plan Git project should be treated as static-only for now.

Option 3: Ask your AI agent

Best when you'd rather not touch a dashboard or a terminal.

1. Paste this into your agent:

   Fetch and follow the instructions at https://deploybase.eu/agent-setup to set me up for deploybase, then deploy this project.
   

2. The agent connects itself and asks you for one key. Only a person can create it, and the agent tells you where.

3. It builds your repository and sends you the link.

This path needs a Git repository for now, so it won't work for a loose folder of files — use drag and drop for that.

Which method should you use?

After the first deploy

• Add your own domain when you're ready — it's the last step in every path, not a prerequisite.
• Roll back instantly if a deploy goes wrong; production is described as a pointer, so rollback doesn't require a rebuild.
• Collect form submissions without a backend if your site needs a contact or signup form.
• Move existing settings over if you're coming from Netlify or Vercel, rather than reconfiguring from scratch.

The fastest way to decide: if you have a repo, push from Git; if you have a folder, drag it in; if you want the setup handled for you and have a repo, hand it to your agent.

Serverless functions on deploybase run alongside your static site but are served from their own hostname — a function named scan in a project called eu-check is reachable at scan-eu-check.fn.deploybase.eu, while the site itself lives at eu-check.sites.deploybase.eu. You write the function code in a functions/ directory in your repository, and it is bundled and deployed automatically on push. Functions are currently in beta and available on paid plans.

The deployment model: one push, two outputs

The key thing to understand is that a site and its functions are deployed together but published separately. When you push, deploybase builds the static output and bundles the functions in the same run, then puts each on its own link.

The documented example build (eu-check, a website with one function, 26 September 2026) shows the sequence:

Output was 12 files / 181.7 KB, framework vite with npm, deployment ba65d07. So the practical expectation is: a small site with one function goes live in roughly half a minute, and the function is part of that same deployment rather than a separate service you configure.

Where the code lives and how it gets a URL

• Put function code in the functions/ directory of your repository. The docs state plainly: "code in functions/ runs beside it."
• Naming follows a fixed pattern: <function-name>-<project-name>.fn.deploybase.eu. The example function scan in project eu-check becomes scan-eu-check.fn.deploybase.eu.
• Your static site keeps its own address: <project-name>.sites.deploybase.eu.

This separation matters for how you wire things up. Because the function is on a different origin from the site, calls from your frontend go to the function's hostname rather than a relative /api/... path. Plan your fetch URLs and any CORS settings around that.

Which deployment routes support functions

deploybase offers three ways to publish, and they are not equivalent for functions:

1. Push from Git — the documented path for functions. Connect GitHub, GitLab, Bitbucket, Codeberg, or Forgejo, push, and every push updates the site while functions/ is bundled alongside it. Every branch also gets a preview link.
2. Drag and drop — upload a folder containing index.html (up to 250 MiB on the free plan). This is described as "no build, no repository," so there is no repository functions/ directory to bundle from.
3. Ask your AI agent — Claude, Cursor, or any MCP client can set up and deploy a project, but this route "needs a Git repository for now."

If functions are the point of your project, the Git route is the one the documentation supports.

Current stage and access conditions

Two constraints are stated directly in the source material and are worth checking before you plan around them:

• Beta. Functions are labelled beta in the build output and in the deployment descriptions.
• Paid plans only. "Functions are in beta on paid plans." The site advertises "free to start" and flat pricing in euros, with a pricing page at https://deploybase.eu/pricing — but the free tier is not described as including functions.

So the working assumption is: you can start a static site for free, but you need a paid plan to use functions, and the feature may change while in beta.

What this means in practice

If you want a static site plus a small amount of server-side logic — a form handler, a scan endpoint, a webhook receiver — deploybase's model is: keep the function in functions/, push, and call it at its own fn.deploybase.eu hostname. You get branch previews and instant rollback on the same deployment, and the whole chain is named and traceable in the build log.

If you need functions on a free plan, or you want to deploy functions without a Git repository, the current documentation does not describe a supported path. In those cases, either move to a paid plan and a Git-connected project, or look at the drag-and-drop route for static-only sites.