blog: Your Own Calendly

Free, Open Source & 100% GDPR-Compliant

Why pay $15 per month for Calendly and send your client data to US servers when you can self-host a better, safer, and completely free alternative?

calendly free tool

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:

  1. Privacy: Details often leak through, or the URL is publicly guessable.
  2. Control: You don’t want people to know how long your lunch break is — only that you’re not available.
  3. Compatibility: Many self-hosted tools need clean .ics feeds, 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.

javascript
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).

javascript
// 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.

javascript
// ... 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).

  1. Fork the repository.

  2. Create a new project on Railway via GitHub Connect.

  3. Set the environment variables:

    • SOURCE_ICS_URL: Your private Google Calendar ICS URL
    • FEED_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.

  1. The frontend is a static page (could be Next.js, plain HTML, or WordPress).
  2. It fetches data from the Busy ICS Proxy.
  3. It displays available time slots based on the “Busy” blocks.
  4. 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:

👉 Go to the GitHub repository

About the Author

Alex Friedl

Alex Friedl

Digital Product Expert

I combine user research, prototyping and TypeScript frontend/API development to shape excellent digital solutions.

Alexander Friedl
Checking...
Checking...

Got a project in mind?

+49 157 581 508 46