Every freelancer and agency knows the dilemma: you need a booking tool. But the big players (Calendly, Acuity, HubSpot) are often expensive — and more importantly — they read your data. For a booking tool to work, it needs to know what’s in your calendar. That usually means third-party providers get access to all your appointment details.
The solution: Build your own privacy-first infrastructure. Keep full data sovereignty.
The missing puzzle piece is often not the frontend (there are great open-source solutions or simple forms for that), but the backend:
How do I share my availability without giving up my privacy?
That’s where the Busy ICS Proxy comes in.
The repository: github.com/alexfriedl/clean-ics-feed-generator
The Problem: Google Calendar Talks Too Much
You could simply share your Google Calendar. But:
- Privacy: Details often leak through, or the URL is publicly guessable.
- Control: You don’t want people to know how long your lunch break is — only that you’re not available.
- Compatibility: Many self-hosted tools need clean
.icsfeeds, not complex Google APIs.
The Busy ICS Proxy is a minimalist Node.js microservice. It sits between your private calendar and the outside world — acting as a “firewall” for your appointments.
The Tech: How the Code Works
The proxy fetches your private calendar feed, calculates all events (including complex recurring ones!), and generates a new feed that contains nothing except: “This time is busy.”
Here’s a look under the hood (Node.js & Express):
1. The Server & Security
We use a simple Express server. An optional security key ensures that not just anyone can access your feed — only your booking app.
import express from "express";
import dotenv from "dotenv";
const app = express();
dotenv.config();
// Middleware for optional security key
app.use((req, res, next) => {
const FEED_KEY = process.env.FEED_KEY;
if (!FEED_KEY) return next();
// Only requests with the correct key can access the feed
if (req.path.endsWith(".ics") && req.query.key !== FEED_KEY) {
return res.status(403).send("Forbidden");
}
next();
});2. The Magic: Parsing & Anonymization
The script uses node-ical to parse the calendar. The tricky part is recurring events.
An event like “Weekly Monday Meeting” only exists once in the calendar, but must be expanded into concrete dates for availability checks.
Additionally, we often need to fix time zones, because servers (like Railway or Heroku) run on UTC, while your calendar is probably in Berlin time (CET/CEST).
// Fetch the original calendar feed
const response = await fetch(process.env.SOURCE_ICS_URL);
const icsData = await response.text();
const events = await ical.async.parseICS(icsData);
// Define time window (e.g. 8 weeks ahead)
const now = new Date();
const eightWeeksFromNow = new Date(now.getTime() + (8 * 7 * 24 * 60 * 60 * 1000));
for (const [key, event] of Object.entries(events)) {
if (event.type === 'VEVENT') {
// Handle recurring events (RRULE)
if (event.rrule) {
const dates = event.rrule.between(now, eightWeeksFromNow, true);
for (const date of dates) {
// Timezone correction for UTC servers (important for Europe/Berlin)
let startDate = new Date(date);
if (process.env.TZ === 'UTC') {
// Simple fix for Europe/Berlin summer/winter time
const month = startDate.getMonth();
const isSummerTime = month >= 2 && month <= 9;
const hoursToAdd = isSummerTime ? 2 : 1;
startDate = new Date(startDate.getTime() + hoursToAdd * 3600000);
}
// Add anonymized busy block
busyBlocks.push({
start: startDate,
end: new Date(startDate.getTime() + duration),
uid: `${key}-${startDate.getTime()}` // Generate unique ID
});
}
}
// Handling for single (non-recurring) events...
}
}3. The Output: 100% GDPR-Compliant
In the end, we generate a valid .ics stream. No matter what the original event was (“Dentist”, “Date”, “Secret Project”) — the output only contains SUMMARY:Busy.
// ... loop through all busyBlocks ...
busyIcs += "BEGIN:VEVENT\r\n";
busyIcs += "SUMMARY:Busy\r\n"; // The key part: no details!
busyIcs += "CLASS:PRIVATE\r\n";
busyIcs += `DTSTART:${dtStart}\r\n`;
busyIcs += `DTEND:${dtEnd}\r\n`;
busyIcs += "END:VEVENT\r\n";Deployment in 2 Minutes (Free)
You don’t need your own server. Railway is perfect for this use case (with a generous free tier / trial).
-
Fork the repository.
-
Create a new project on Railway via GitHub Connect.
-
Set the environment variables:
SOURCE_ICS_URL: Your private Google Calendar ICS URLFEED_KEY: Your password (e.g.mySecretKey123)TZ:UTC(or your server timezone)
That’s it. Your URL will look like this:
https://your-project.railway.app/busy.ics?key=mySecretKey123
Use Case: Your Own Booking Page
Now you have the backend. What can you do with it?
Check out alexfriedl.com/booking — it runs exactly this setup.
- The frontend is a static page (could be Next.js, plain HTML, or WordPress).
- It fetches data from the Busy ICS Proxy.
- It displays available time slots based on the “Busy” blocks.
- The user books a meeting → it’s written back to your calendar via a form or webhook.
The result:
- You save ~$150/year in SaaS costs.
- No US company analyzes your meeting patterns.
- Full control over design and UX.
- Your clients only see when you’re available — never why you’re busy.
Get the code and start building your own sovereign booking system:


