How to create a conference management system with no-code

Running a conference can be a practice in controlled chaos. 

There are speakers to confirm, sessions to schedule, rooms to assign, badges to print, registrations to process, and a thousand small details that all have to align perfectly in real time. Most conference ops run on a mix of spreadsheets, emails, and pure sweat equity. 

When everything is clicking into place and running, this works smoothly. But when you need to pivot plans at the last minute, put out a fire in the middle of a session, simply scale your operations as your conference grows, this system starts to fail. Across all of these challenges, there’s a common root issue: conference operations are highly dynamic, but most teams manage them with static tools. That mismatch between fast-changing, real-world logistics and rigid systems is what creates most of the friction.

With a no-code platform like Glide, you can build a fully custom conference management system tailored exactly to how your team works, without writing a single line of code. It can connect all your disparate systems together, adapt easily as your needs change, and give you an operational control tower right on your phone.

Mark Turrell runs UnDavos, the largest side conference at the World Economic Forum, and used Glide to run a 3,000-delegate conference with a fraction of the headcount most events of that scale require. “With the DavosWeek app and unDavos, we can get more people into the room together,” he said, “...our event scaled 100x in 3 years, and it would not have been possible without Glide.”

This guide walks through exactly why and how you can create your own conference management system, and adapt it to exactly what your event needs to run smoothly and successfully. 

What do you need from your tech to run a successful conference?

Conference management, at any meaningful scale, involves coordinating dozens (or hundreds) of people across multiple venues, time slots, topics, and roles, often for months leading up to a single week. These are some of the key abilities you might need to run your ideal conference. With a no-code tool like Glide, you can build in features as your event scales and your needs grow.

1. Reliable tools that connect to each other seamlessly. You need a single source of truth for your conference that is accurate in real time. You don’t want to be shifting between a half dozen tools with their own logins or doing constant manual copy-and-pasting to keep your data unified. You also need these tools to be robust enough that they won’t break under pressure on conference day.
2. Adaptability to last-minute changes. You should be able to track engagement and issues in real time and get a live view of attendance by sessions. This keeps you informed of any crises that pop up so you can adapt and improve the experience mid-event. 
3. Day-of operations support. You need to keep your staff updated on current information, schedules, and maps throughout the day of the conference. Everyone needs real-time visibility and easy communication to coordinate between check-ins, sessions, and support teams
4. Speaker, & agenda coordination. You need to be able to easily sort speakers into sessions, panels, and workshops, adapt to last-minute cancellations or schedule changes, and easily communicate with everyone involved.
5. Venue coordination. What building, what room in that building, and what time slot? To manage your conference, you need a clear, eagle’s-eye view of all your physical spaces and the ability to shift things if last-minute problems arise.
6. Attendee registration & communication. You need an easy and organized way to register attendees, check them in seamlessly at the door, and communicate with them before, during, and after the event. You should also be able to segment them if needed. This will make sure attendees aren’t confused and have a great, professional experience. 
7. Post-event follow-up & ROI measurement. You need a way to keep momentum going with attendees and speakers, collect solid feedback for the next year, and clearly link event outcomes and business impact to justify the event or improve the next one.
8. A process that can scale as your event grows. If this year was a success, can you build an even better conference next year without rebuilding your whole system or getting lost in a sea of spreadsheets?

Common challenges in conference management tools

The logistical challenge of running a conference is real, and the tools most teams reach for aren't built for it. These are the common roadblocks teams run into with the typical tech stack:

Spreadsheets break at scale

Spreadsheets are where most conference management starts, and for small events, they work fine. But as your event grows, spreadsheets become liabilities. There's no real-time collaboration. Version control causes endless headaches. Data lives in silos, with your speaker list in one sheet, your room assignments in another, your schedule in a third, and so on. Keeping everything in sync is a manual, error-prone process.

When something changes, a speaker cancels, a session gets moved, a room becomes unavailable, you have to chase updates across multiple files, and hoping nothing slips through the cracks. At a certain scale, things will slip through the cracks. As unDavos founder Mark Turrell put it bluntly:

"We used to operate on spreadsheets four years ago, but it's unmanageable at this scale."

Hiring more people isn't a sustainable solution

When operations start getting too big to manage, hiring additional hands is the obvious solution. While a capable team is always valuable, using headcount to compensate for process and tooling gaps is expensive and still fragile. More people mean more coordination, more communication overhead, and more potential for things to fall out of sync.

Even when you have enough people on hand to run operations, you're also betting that everyone has the same information at the same time, which they rarely do. As events grow, this approach doesn't scale.

Off-the-shelf software is rarely a good fit

There are plenty of event management platforms on the market. These off-the-shelf platforms are typically either so narrow in focus you have to cobble together multiple tools to create a comprehensive system, or are so exhaustive you end up paying massive Enterprise-level fees for features you don’t touch. 

For standard use cases, some of them may work well, but most conferences have specific workflows, unique data relationships, and requirements that generic software doesn't accommodate. You end up adapting your process to the tool rather than the other way around. They also tend to lock you into their ecosystem. Integrations are limited or expensive. You can't customize the interface for your team's specific roles, and when your event evolves, you can’t adjust your system to keep up.

Why Build a Custom System with Glide

Glide is a no-code platform that lets you build fully functional, mobile-friendly apps connected to your data, no developers required. For conference management, this is a significant advantage. You're not working around someone else's feature set; you're building exactly the system your event needs.

Your tools fit your process, not the other way around

Every conference is different. Some have strict speaker vetting processes. Others manage dozens of parallel sessions across multiple venues. Some need tiered access for sponsors, staff, speakers, and attendees, so that each group sees different views of the same event. When you create your own system in Glide, you define the data model and the workflows, so your tools map to how you actually run things.

One source of truth, accessible from anywhere

Glide apps are built on top of your data, whether that's Excel, Google Sheets, Airtable, or Glide Tables. Every user interacts with the same live data. When a session is moved or a speaker is confirmed, the update is applied instantly across the entire system. No more chasing spreadsheet versions or sending "updated schedule" emails.

For Mark Turrell at unDavos, this was critical. "For me, by 7:45, my day has already started, and I'm running the conference at the same time," he explained. "If I learn we fill a time slot on Tuesday, I can go into my app and do it immediately. I can change the presentation time in one click, and it propagates through everything."

Powerful integrations without engineering work

A modern conference stack typically involves multiple tools: registration platforms, website CMS systems, badge generation, communication tools, and data enrichment services. Glide integrates with all of these through native connections and API workflows, letting you build a system where data flows between tools automatically.

The unDavos team connected Glide to Luma for registration, Webflow to update their public-facing website, CredsNow for badge generation, Clay for data enrichment, and WhatsApp for speaker communication, all managed from within their Glide apps.

Savings on headcount and cost

One of the most compelling arguments for a well-built Glide conference system is what it saves you. Mark Turrell estimated that their Glide setup saved them from needing to hire 10 to 12 people to run conference operations. At any reasonable salary estimate, that's hundreds of thousands of dollars in annual costs for an event that keeps growing.

"Using Glide to manage the conference probably saved us needing to hire 10 or 12 different people. In addition to that, it would be impossible to scale, and we'd have more holes in between the processes."

Mobile-first and available on-site

Glide apps work natively on mobile, which matters enormously when you're actually running a conference. Being able to pull up your app, make a change, and have it reflect everywhere is a different experience from opening a laptop and navigating a complex dashboard. On a busy event day, that difference is everything.

How to Build a Conference Management System in Glide

You can build a conference management system in Glide using the drag-and-drop interface, and it doesn’t require any coding. You’ll organize your data, design an interface, and then add more advanced features like AI, automation, and integrations with the rest of the software you use to run your conference.

Here's a step-by-step guide to creating your app. If you want more detailed tutorials, check out the resources in Glide University.

Step 1: Set up your spreadsheets to connect to your app

Create a new Glide app and connect your data source. 

Most apps start with a spreadsheet, since that’s where your key data already lives. You can start with Excel, Google Sheets, Airtable, SQL databases, or use Glide Tables, the platform’s native database. 

Before uploading your sheet to Glide, make sure it clearly maps out the core entities in your conference. These typically include:

• Events / Sessions (with title, description, date, time, session type, status)
• Speakers and panelists (with bios, photos, LinkedIn, topic tags, confirmation status)
• Venues and rooms (with capacity, AV setup, assigned sessions)
• Time slots (tied to both rooms and sessions)
• Attendees (registration info, ticket type, attendance status)
• Sponsors (tier, contact, assets, visibility settings)
• Staff and volunteers (roles, assignments, communication preferences)

Step 2: Build your admin interface

Next, design your interface. There is no need to build interfaces for different devices. Your design will work seamlessly on any device, including smartphones, tablets, and computers, since Glide uses automatically adaptive design.

The core of your conference management system is the admin app. This is what your team uses to run operations. You can design dashboards to display data using charts, lists, and detail views. Add buttons that let you take action, like editing a session or emailing a speaker. Add forms to input data in a structured way, such as a new venue or a new panel session. 

Build different tabs that you can use to keep operations organized. Key screens to build include:

• Sessions: A session management view with the ability to assign rooms, time slots, speakers, and session status in one place
• Speakers: A speaker roster with confirmation status, headshots, bios, and quick-link to their assigned sessions
• Rooms: A room and venue overview showing what's scheduled when and where
• Registration: A registration dashboard showing attendee counts, ticket types, and waitlist status
• Sponsors: A sponsor management view with contact info, assets, and visibility controls

Step 3: Connect your integrations

Next, connect third-party software integrations with the tools your team will need to use. This could be connecting to Gmail to contact speakers or linking up with a comprehensive registration system. Here are some of the most useful integrations:

Registration

For event registration, Luma is one of the most natural integrations for Glide-powered conference systems. Set up your Luma event and connect it to your Glide backend using Glide's workflow automation. When someone registers through Luma, their information flows into your attendee table, triggers any necessary automation (welcome emails, badge generation, session recommendations), and is immediately available to your team in the admin app.

Badge Generation

Badges are one of the most satisfying things to automate. Connect Glide to a badge generation service like CredsNow. When a participant is confirmed, Glide triggers the badge generation workflow: the system creates a branded and personalized badge with the participant's name, role, headshot, and a unique QR code. On event day, staff can scan QR codes for instant check-in, and attendees can scan other badges to exchange contact info immediately.

LinkedIn

You can also enable LinkedIn data import at the point of registration, which, as we'll see with unDavos, opens up many useful options for AI-assisted speaker and attendee curation.

Step 4: Add AI and automation workflows

Once your data is clean and your integrations are running, the most powerful step is layering in AI-assisted automation. Glide's built-in AI features let you run workflows like:

• Auto-tagging sessions and speakers by topic based on their descriptions
• Scoring attendee-session match using LinkedIn data and registration info
• Generating personalized session recommendations for each attendee
• Drafting communications to speakers and panelists based on session details
• Flagging scheduling conflicts automatically when room or speaker assignments are made

These automations don't just save time; they make decisions smarter. For a conference with hundreds of sessions and thousands of attendees, AI-assisted curation is the difference between a generic schedule and one that actually connects the right people.

Step 5: Connect your public-facing tools

Your conference management system shouldn't just serve your internal team; it should also drive what the public sees. Use Glide's workflow integrations to publish sessions and speakers to your public website (Webflow works especially well here). When you update a speaker's bio or confirm a new session in your Glide admin app, those changes automatically propagate to your public site, no separate CMS login required.

Similarly, if you're running a public-facing attendee app, you can build that in Glide too, or connect your Glide back end to a custom front end for greater design flexibility, as the unDavos team did with Replit.

Step 6: Set privacy and visibility controls

You can control access to your app using an email domain or restrict it to specific email addresses. This keeps your conference data secure. 

If you have additional collaborators who need to use your app and want to control the visibility of certain data, you can use Glide's role-based access control to set up different permission levels. Admins get full access. Staff see only what they need for their role. Moderators can view and message speakers. Volunteers see check-in tools. Different roles should see a different version of the app tailored to their responsibilities.

Step 6: Publish and share 

When your app is working, customize the appearance and hit publish. You can now share your app with your team using a URL, email, or scannable QR code. 

You can continue to iterate on your app, making changes as-needed without impacting its functionality. The beauty of building in Glide is that changes are fast. If you discover a missing field, a broken view, or a new workflow you need three days before your event, you can build it in hours, not weeks.

Features to add to your conference management system

A core conference management system covers the basics: sessions, speakers, rooms, and registrations. But the most useful systems go further. Here's a list of features worth building out as your system matures.

QR code badges for speakers, staff, and attendees

Auto-generate personalized badges for every participant with a unique QR code embedded. Badges should be role-specific (speaker, sponsor, staff, attendee) with distinct visual designs. On event day, staff can use the app to scan QR codes for check-in, and participants can scan each other's codes to exchange contact information instantly, a significant upgrade from paper business cards.

The QR codes can be linked to the participant's profile in your system, their LinkedIn, or a digital business card, whatever makes the most sense for your audience.

Event registration with Luma integration

Use Luma as your registration front-end and sync everything to Glide on the back end. This gives attendees a polished registration experience while giving your team a single source of truth for registrant data. Set up registration questions for your Luma event directly in Glide, so you don't need to log in to multiple platforms. You can also configure registration tiers — general admission, VIP, speaker registration, each triggering different workflows and data flows in your system.

AI-assisted speaker and attendee vetting

When attendees or speakers register, prompt them to connect their LinkedIn profile. Use Glide AI to analyze that data against your session topics and flag each person as a strong match (green), possible match (yellow), or low relevance (red) for different sessions or panels. This significantly reduces the manual work of reviewing applications, allowing your programming team to focus on interesting decisions rather than administrative ones.

Quick speaker and panelist assignment

Build a session assignment interface that lets admins drag-and-drop or quick-select speakers and panelists for each session. Include smart filtering: filter speakers by topic expertise, availability, previous participation, or match score. Show conflicts automatically; if a speaker is already booked in an overlapping time slot, flag it immediately. This single feature can save hours of back-and-forth when building your program.

Room assignment and scheduling dashboard

A visual room assignment view showing a grid of all rooms against all time slots is one of the most useful things you can build. Admins should be able to see at a glance which rooms are booked, which are free, and whether capacity matches expected attendance. When sessions are moved or added, the dashboard updates in real time. Add alerts for double-bookings or capacity conflicts.

Role-based access for moderators, staff, and volunteers

Different people need different views. Build out roles carefully:

• Moderators: Can view all speakers in their sessions, send batch messages, and update session status on the day.
• Staff: See their assigned areas, check-in tools, and shift information. Can't edit session or speaker data.
• Volunteers: Simple mobile view for check-in, room directions, and shift notes.
• Speakers: See their own session details, co-panelists, room information, and any updates from the organizer.

Glide's role-based access control makes this manageable without duplicating your entire app. You define rules once, and the system handles what each role sees.

In-app messaging and WhatsApp integration

Build communication tools directly into the system. Staff and moderators should be able to message speakers and panelists in bulk or individually, especially useful in the days leading up to a session when last-minute details need to be shared. With WhatsApp integration, those messages can reach people on their phones without requiring them to log into your app. This is particularly useful for communicating with speakers who may not have downloaded your conference app.

Attendee-facing event discovery app

Build a separate attendee-facing app that surfaces the full conference program, speaker profiles, and venue information. Include search and filtering so attendees can find sessions relevant to their interests. For larger events, consider adding an AI-powered recommendation engine that curates a personalized schedule for each attendee based on their registration data, topic preferences, and app browsing behavior.

Sponsor management and visibility controls

Sponsors deserve more than a logo on a website. Build a sponsor management module that tracks each sponsor's tier, contact, deliverables, and visibility settings. Give sponsors their own portal where they can update their profile, see analytics on how many attendees viewed their content, and manage their presence at the event, without giving them access to your internal operational data.

Post-event surveys and feedback collection

Build session-specific feedback forms directly into your attendee app. After each session, attendees get a prompt to rate the speaker, the content, and the room setup. Feedback flows back into your Glide system, where you can analyze it by speaker, topic, room, or time slot. This data is invaluable for improving future events and for sharing feedback with speakers after the conference.

Livestream and content publishing integration

If you're broadcasting sessions live or publishing recordings afterward, your conference management system should track this too. Add fields for stream URLs, recording links, and content status (live, recorded, published, not recorded). Automate publishing. When a recording is uploaded, trigger a workflow that notifies registered attendees, updates the public program page, and sends a social post.

Multi-conference support

If you're running multiple events or plan to license your system to other organizations, build with multi-tenancy in mind from the start. Glide's data model can support multiple conference teams using the same app infrastructure without mixing their data. Each organization gets its own view, its own Luma connection, its own Webflow site, all managed from a shared Glide backend. This is exactly the architecture the unDavos team built, and it's already being used by other conference organizers.

unDavos Summit created a multi-conference management system in Glide

Read the story

Real-World Example: How unDavos Summit Built a Conference System That Scaled 100x

If you want a proof of concept for what a Glide-powered conference management system can look like at a serious scale, the unDavos Summit is it.

About unDavos

The unDavos Summit is the largest independent conference running alongside the World Economic Forum's Annual Meeting in Davos, Switzerland. With 3,000 delegates, over 400 speakers, and more than 100 sessions, plus a broader ecosystem of 1,200+ side events collectively known as DavosWeek, it's an operationally complex event by any measure. In 2026, DavosWeek saw more than 18,000 attendees moving through over 1,200 events.

Founder Mark Turrell built the first version of his conference system himself, then enlisted Glide Expert Abdo Awad of LessCode Agency to further develop it. The result is a multi-app Glide stack that runs the entire event.

"We run a 3,000-delegate conference with 400 speakers and hundreds of sessions, all managed with a set of Glide apps."

The tech stack

The unDavos conference system is built across multiple connected Glide apps, each serving a different function:

• Conference Management System: The operational backbone. Used to organize venues, rooms, time slots, sponsors, speakers, workshops, panels, and sessions.
• DavosWeek App: The public-facing directory of all side events in Davos, available to a global audience. The Glide backend connects to a Replit front end for additional design flexibility.

As Abdo described it: "There's a lot of Glide within unDavos. It's the major source of truth for the data that unDavos deals with, and so Glide is the core of our tech stack."

Key integrations

The unDavos system is notable for how many tools it connects to, all coordinated through Glide:

• Luma: Handles event registration. When attendees register, they can link their LinkedIn data. From within Glide, the team can publish events to their Luma calendar and configure registration questions, without logging into Luma directly.
• Webflow: Their public website is managed from within Glide. Speaker updates, session changes, and hero text on the website all push automatically from the Glide system, no separate CMS login needed.
• CredsNow: Generates unique digital badges for all participants. Each badge includes a QR code that attendees can scan to connect with each other instantly. Mark noted that the integration was so easy to set up, he did it "basically on Sunday before the event started."
• Clay: Data enrichment. Used to expand and verify information about speakers and attendees.
• WhatsApp: Planned for next year as a speaker and panelist communication channel, tied to Glide's moderator role.

AI-powered speaker and attendee curation

One of the most powerful features of the unDavos system is its AI-assisted vetting process. When attendees register through Luma and provide permission to connect their LinkedIn data, the system uses AI to analyze their professional profile against the topics of each session.

The result is a red/yellow/green scoring system for each potential speaker or attendee relative to each session. Red means low relevance, yellow means possible fit, and green means strong match. What used to require hours of manual review now happens automatically, dramatically accelerating the work of building a well-matched, high-quality program.

AI discovery features for attendees

On the attendee side, the DavosWeek app includes what Mark jokingly calls "unDavos Tinder". This is an AI-powered discovery feature that lets users swipe through cards of people, events, showcases, and tips they might be interested in, all personalized based on their app activity and search behavior.

The app uses Glide AI to generate cards and curate recommendations, learning from users' search queries and interactions. With over 1,200 events in the system, this kind of personalization isn't a nice-to-have; it's what makes the app actually useful.

The results

The unDavos Summit:

• Saved the equivalent of 10-12 full-time hires in conference operations
• Scaled from roughly 1,000 events to 1,200+ events and 18,000+ attendees in just a few years
• Runs a 3,000-delegate conference with a small team, all coordinated through mobile
• Has expanded the platform to support other conferences, including the Human Change Foundation

"We have the largest conference system with the lowest headcount of anybody. Our event scaled 100x in 3 years, and it would not have been possible without Glide."

The system has become so capable that other conference organizers have started using it. "In this current form, it's a multi-conference management system," said Abdo. The team is now looking at events of similar scale and complexity, such as UNGA, New York Climate Week, and the Munich Security Conference, as potential users of the platform they built.

Lessons from unDavos

A few things stand out from the unDavos experience that are worth taking forward into your own build:

• Start with your most painful problem. For Mark, it was the speaker intake process: "Before, we had a Google Form that people would fill out if they wanted to speak or host a panel. Now it's a Glide app." Fix the worst bottleneck first.
• Mobile-first matters on event day. The ability to manage the conference on a phone while running it simultaneously was what made Glide genuinely transformative for Mark's team.
• Build for the integrations early. The power of the unDavos system comes from the number of tools that connect to Glide as a central hub. Design your data model with those connections in mind from the start.
• Consider a Glide Expert. Mark started building himself, then brought in LessCode Agency for the more complex build. For teams that want to move fast and build something production-ready, working with a certified Glide Expert is often the most efficient path.

Build and grow a successful conference management operation

You don't need to build the full unDavos stack on day one. The right approach is to start with your most pressing operational pain points, usually speaker management, session scheduling, or registration sync, and build from there. Glide's drag-and-drop builder lets you build a working app in hours, not months.

If you're planning an event and want to explore what a custom conference management system could look like for your team, start by mapping out the data you already manage in spreadsheets, email, or across various tools, and think about what a single, connected system would make easier. That's your starting point.

The technology to run a world-class conference with a lean team already exists. The unDavos Summit is proof that it works.