How I Replaced Eventbrite With a Lean No-Code Stack for Multi-City Events

From Eventbrite headaches to a scalable stack powered by Zapier, Outseta, and Cloudflare Workers.

The Pain Point: Eventbrite Fees and Friction

When I first started organizing social events in Ottawa, I used Eventbrite to handle ticketing. It worked well at first — it had solid marketing features and good reach.

But as my events grew, two major problems surfaced:

1. High fees were eating into already-tight margins.
2. Their support team failed to resolve technical issues, which meant lost ticket sales.

As someone running everything solo, I needed a lean, reliable, and scalable system that could grow with me — not against me. That’s when I decided to ditch Eventbrite and build my own hybrid no-code + light code stack.

The Core Stack

My goal was simple: use best-in-class tools for each function, and stitch them together seamlessly without building everything from scratch.

Here’s the backbone of what powers the National Social Networking Group today:

        +-------------+       +---------+       +---------+       +-----------+
        |   Website   |  -->  | Ticket  |  -->  | Zapier  |  -->  |  Outseta  |
        | (Weblium)   |       | Tailor  |       |        |       | Membership|
        +-------------+       +---------+       +---------+       +-----------+
               |                                             |
               |                                             v
               |                                      +--------------+
               |                                      | Mailchimp    |
               |                                      | Notifications|
               |                                      +--------------+

• Weblium – The main website, which embeds event listings directly from Ticket Tailor.
• Ticket Tailor – Handles ticket sales with lower fees and better support than Eventbrite.
• Zapier – Glues everything together with no-code automations.
• Outseta – Manages memberships and recurring billing.
• Mailchimp – Sends out event notifications and updates.

Solving Membership Validation Without Code

One of the biggest early challenges was how to integrate memberships into the ticketing flow.

Ticket Tailor doesn’t support monthly subscriptions natively. So I had three choices:

• Use a platform like Memberstack, Podia, or Outseta for memberships
• Build my own system (not feasible as a solo founder)
• Or combine existing tools intelligently.

I chose Outseta for its flexibility and Zapier support.

Here’s what happens behind the scenes when a member buys a ticket:

[TICKET PURCHASE] --> [ZAPIER checks Outseta] --> 
   if email is valid member --> [apply exclusive member pricing]
   else --> [regular ticket pricing applies]

This entire flow is handled by a single Zap, but that one automation saves me weeks of development time. It also allows me to scale to multiple cities without custom dev work.

💡 Why Zapier? It requires no code, integrates with both platforms, and gives me flexibility to evolve the flow later as we scale.

Website Evolution: From Carrd MVP to Weblium

When I first launched, I used Carrd — a one-page website builder — as my MVP. It was fast, cheap, and perfect for getting the idea off the ground.

But as we expanded to Ottawa, Toronto, and Montreal, a single page wasn’t enough. Each city needed its own event listings, membership sections, and more flexibility.

So I migrated to Weblium, which allowed me to:

• Embed Ticket Tailor event listings directly
• Build multiple pages for each city
• Keep the site lightweight and easy to manage without developers

Carrd isn’t gone — I still plan to use it for landing pages and micro-campaigns in the future. But for the main site, Weblium gave me the structure I needed.

Dynamic Event Links with Cloudflare Workers

Another challenge came up as we scaled: How could I share one simple link per city that always redirected users to the latest upcoming event, without manually updating URLs every time?

Ticket Tailor didn’t have this feature out of the box. So I built a lightweight solution using Cloudflare Workers and the Ticket Tailor API.

The logic is simple:

1. Parse the URL path for a city keyword (e.g., /ottawa)
2. Call the Ticket Tailor API for all published events
3. Filter events whose names match the city keyword
4. Sort by date and redirect to the soonest upcoming event

Here’s the full Worker code:

export default {
  async fetch(request) {
    const API_KEY = "";
    const encodedKey = btoa(`${API_KEY}:`);

    // Extract city keywords from URL path
    const url = new URL(request.url);
    const rawPath = url.pathname.replace(/^\/+/, "").toLowerCase();
    const cityKeywords = rawPath ? rawPath.split("-") : [""];

    const apiUrl = "https://api.tickettailor.com/v1/events?status=published";
    const response = await fetch(apiUrl, {
      method: "GET",
      headers: {
        Authorization: `Basic ${encodedKey}`,
        "Content-Type": "application/json"
      }
    });

    const result = await response.json();
    if (!result.data || result.data.length === 0) {
      return new Response("No published events found.", { status: 404 });
    }

    const now = Date.now();
    const matchingEvents = result.data.filter(event => {
      const name = event.name?.toLowerCase() || "";
      const startTime = new Date(event.start?.iso || 0).getTime();
      return startTime > now && cityKeywords.some(keyword => name.includes(keyword));
    });

    if (matchingEvents.length === 0) {
      return new Response(`No upcoming events found for: ${cityKeywords.join(", ")}`, { status: 404 });
    }

    matchingEvents.sort((a, b) => new Date(a.start.iso) - new Date(b.start.iso));
    const redirectUrl = matchingEvents[0].url;

    return Response.redirect(redirectUrl, 302);
  }
};

This single Cloudflare Worker supports all cities dynamically — no extra code required when we expand. It’s lightweight, fast, and currently powers the city-specific links we share in our marketing channels (e.g., Instagram bios, email campaigns).

Why I Chose Integration Over Rebuilding

I get asked why I didn’t just hire developers and build my own event platform.
The answer is simple:speed, cost, and focus.

• Rebuilding everything would have taken months and cost tens of thousands.
• This hybrid no-code + light code stack was up and running in weeks.
• Each piece (Ticket Tailor, Zapier, Outseta, Cloudflare Workers) is independently scalable.

For a bootstrapped startup, this approach made far more sense.

What’s Next?

We’re currently using one core Zap, but as we expand to more cities, I plan to add:

• Automated city-specific email sequences
• Dynamic pricing adjustments
• Advanced membership segmentation

Rather than reinventing the wheel, I’ll keep strengthening integrations — making the stack smarter without bloating it.

Final Thoughts

You don’t need a dev team to build something powerful. With the right tools, a bit of glue code, and smart architecture, you can create a multi-city, revenue-generating platform that scales.

This stack has allowed me to:

• Ditch expensive platforms like Eventbrite
• Automate critical workflows
• Support multiple cities with minimal maintenance

If you’re curious to see the platform in action, check out National Social Networking Group

And the best part? I built it all myself.