Static websites are everywhere now — portfolios, landing pages, documentation sites, and small SaaS marketing pages.
But they all run into the same problem:
How do you handle a contact form if there is no backend?
Normally a form submits data to a server, but static sites don't have one.
In this article we'll look at three common ways developers handle HTML forms without running their own backend.
HTML forms send data using an HTTP request, usually a POST.
A typical form looks like this:
<form action="/contact" method="POST">
<input type="text" name="name">
<input type="email" name="email">
<textarea name="message"></textarea>
<button type="submit">Send</button>
</form>
When the user submits the form, the browser sends the data to the URL defined in the action.
Normally that endpoint is handled by a backend such as:
- Node / Express
- Python (Flask or Django)
- PHP
- Ruby on Rails
The server then processes the submission by:
- validating the data
- sending email notifications
- storing submissions
- triggering webhooks or automations
Without a server endpoint, the browser has nowhere to send the form data.
If you're comfortable with backend development, you can create your own endpoint.
Example using Express.js:
app.post('/contact', (req, res) => {
const { name, email, message } = req.body
// validate input
// send email
// store submission
res.json({ success: true })
})
Example using Flask:
@app.route('/contact', methods=['POST'])
def contact():
data = request.form
# process submission
Pros
- full control
- fully customizable
- easy to integrate with your own database
Cons
- requires hosting a backend
- you must manage spam protection
- email delivery can be tricky
- more maintenance
For many small sites, this can be overkill.
This is the most common approach for static sites.
Instead of building your own server, you send form submissions to a hosted endpoint.
Some popular options include:
- Formspree
- Basin
- Getform
- Formkeep
Example:
<form action="https://formspree.io/f/your-form-id" method="POST">
<label>Name</label>
<input type="text" name="name" required>
<label>Email</label>
<input type="email" name="email" required>
<label>Message</label>
<textarea name="message" required></textarea>
<button type="submit">Send</button>
</form>
These services typically handle:
- spam filtering
- submission storage
- email notifications
- webhooks
Pros
- extremely easy to set up
- no backend required
- good for static sites
Cons
- usage limits on free plans
- usually email-only notifications
- less flexibility than a custom backend
Option 3 — Messaging Notifications (WhatsApp / SMS)
One limitation of email-based forms is slow response time.
For some use cases — especially leads or support requests — email notifications can easily be missed.
Some newer form backends now deliver submissions to messaging platforms instead.
Examples include:
- WhatsApp alerts
- SMS notifications
- Slack or webhook integrations
This makes it much easier to see enquiries immediately, especially on mobile.
For example, some tools send the form submission to WhatsApp first, with email used as a backup if messaging delivery fails.
If you're exploring this approach, here's a comparison of tools that support messaging notifications:
https://web2phone.co.uk/blog/best-form-backend-whatsapp-notifications-2026/
Quick Comparison
| Approach | Difficulty | Best For |
|---|
| Build your own backend | High | Full-stack applications |
| Form backend service | Low | Static websites |
| Messaging notifications | Low | Time-sensitive enquiries |
What Developers Usually Look For
When choosing a form backend, developers often care about:
- spam protection
- rate limiting
- webhooks
- submission logs
- domain allow-listing
- multiple notification channels
These features become more important as a project grows.
Final Thoughts
Handling forms without a backend is much easier today than it used to be.
Developers now have several options:
- building their own backend
- using hosted form services
- sending notifications to messaging platforms
For most static sites, a hosted form backend is the fastest and simplest solution.
The best option depends on your stack, your project's complexity, and how quickly you need to respond to incoming submissions.
If you're interested in messaging-based form notifications, I also wrote a deeper comparison here:
https://web2phone.co.uk/blog/formspree-vs-web2phone-2026/