Organising a large-scale tech conference has traditionally been an exercise in administrative brute force, requiring substantial capital and legions of event coordinators. At aiDotEngineer Singapore, a lean crew of just five part-time professionals overturned this paradigm. By reframing event management as a pure data-synchronisation problem and deploying an AI-native operational stack—including Convex, Next.js, Devin, and custom browser agents—they successfully orchestrated a conference for over 1,000 attendees, 100 speakers, and dozens of global sponsors. This dispatch analyses the architectural design patterns, data philosophies, and structural automations that allowed a micro-team to achieve institutional-grade execution in one of the world's most competitive technology hubs.
The Chaos of the Physical Interface
To walk through the bustling tech enclaves of Tanjong Pagar or the pristine halls of the Marina Bay Sands Expo Centre is to witness Singapore’s insatiable appetite for the future. As the city-state aggressively executes its National AI Strategy 2.0 (NAIS 2.0), it has fast become the undisputed gravitas centre for the Asia-Pacific compute economy. Yet, behind the elegant keynotes and sleek product rollouts lies a messy, deeply human reality.
When the team behind aiDotEngineer Singapore set out to convene the region's elite machine learning engineers, cloud architects, and founders, they faced a daunting operational calculus. A conference scale of 1,000-plus physical attendees is not merely a static Notion document paired with a booked venue. It is a highly volatile, real-time network of moving parts: fluctuating speaker itineraries, shifting sponsorship assets, ticket reassignments, dietary restrictions, room capacities, waitlist dampening, and an incessant deluge of inbound queries across Slack, WhatsApp, email, and X (formerly Twitter).
Traditionally, mitigating this operational chaos required raw headcount. Event management agencies deploy armies of coordinators to manually reconcile spreadsheets, chase missing assets, and manage registration desks. But in Singapore's hyper-competitive talent market, where headcount costs are high and human bandwidth is best spent on strategic curation, the manual approach is a systemic vulnerability.
The five-person team at aiDotEngineer—all of whom maintained demanding full-time roles alongside this project—refused to staff the chaos. Instead, they recognized that the primary failure mode of large events is not physical; it is informational. Long before a badge is printed or a microphone is switched on, the battle is won or lost in how information flows across the digital infrastructure. The team’s core thesis was simple: turn the entire conference into an integrated software system, writing bespoke automation whenever a workflow threatened to repeat itself.
Event Ops as a Pure Data Problem
At its core, a scaled conference is a data consistency problem. The operational friction does not stem from a lack of information, but from its fragmentation. Consider the standard lifecycle of an event asset:
A speaker updates their bio over a WhatsApp message.
A corporate sponsor uploads a revised high-resolution booth asset to a buried Google Drive folder.
A ticket buyer inputs their corporate billing address, which completely diverges from the email and name of the actual engineer attending the technical workshops.
A high-traffic session reaches its physical fire-safety limit while hundreds of waitlisted attendees remain stuck in an asynchronous email queue.
When these data points live in siloed, disconnected platforms, the system inevitably degrades into stale spreadsheets, buried group chat threads, and administrative blindness. The moment a registration desk agent needs to make a definitive verification in twenty seconds under the gaze of a queue stretching down the corridor, an outdated spreadsheet is worse than useless—it is a liability.
The structural remedy adopted for aiDotEngineer Singapore was the immediate deprecation of the "archipelago of loose spreadsheets." The conference required a singular, reactive backend capable of serving as the ground truth for all downstream applications.
The team selected Convex as their centralized transactional database, leveraging its real-time, deterministic execution engine to handle state changes seamlessly. On top of this data layer, Next.js provided the agile web surfaces required for public-facing portals and internal admin dashboards. Resend was integrated directly into the transactional loops to govern email communications, while DevinAI, OpenAI Codex, and Cursor AI functioned as autonomous and semi-autonomous engineering teammates, writing the glue code, edge functions, and internal applications necessary to keep pace with evolving operational requirements.
By binding these components into a unified architecture, the team could stop manually reconciling rows and focus entirely on engineering the reconciliation flow itself.
+---------------------------------------------------------------------------------+
| THE ARCHITECTURE |
+---------------------------------------------------------------------------------+
| |
| [ Public Front Door ] ---> Next.js Web App (Built with DevinAI assistance) |
| | |
| v |
| [ Core Data Layer ] ---> Convex Backend (Real-time, reactive ground truth) |
| | |
| +---> /api/v1 (Machine-Readable Endpoints) |
| | |
| +---> Speaker/Sponsor Portals |
| | |
| +---> Workshop OS & Live App |
| | |
| v |
| [ Action Layer ] ---> Resend (Transactional Email Engine) |
| Manus AI (Autonomous Outreach & Sourcing Agents) |
| Cursor & Codex (On-the-fly Edge Tooling) |
| |
+---------------------------------------------------------------------------------+
The Architectural Blueprint: Beyond the Visible Website
For the casual observer browsing the internet, a conference website is the digital front door—a clean, aesthetic layout displaying speaker headshots, sponsor logos, and an agenda. However, in an AI-native operational framework, the visible website represents only the tip of the architectural iceberg. To bypass the friction of manual coordination, the aiDotEngineer team engineered an interconnected suite of custom applications all querying and mutating the same Convex backend:
┌──────────────────────────────────────┐
│ Convex Data Layer │
└──────────────────┬───────────────────┘
│
┌───────────────────────────┼───────────────────────────┐
▼ ▼ ▼
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ Speaker/Sponsor │ │ Workshop OS │ │ Live App │
│ Portals │ │ (Waitlists/Sync)│ │(live.65labs.org)│
└─────────────────┘ └─────────────────┘ └─────────────────┘
The Speaker and Sponsor Portals (aie.65labs.org)
The traditional method of gathering speaker metadata—bios, talk descriptions, profile images, travel logistics, and dietary requirements for VIP dinners—is fundamentally broken. Humans do not communicate linearly; one speaker will email a headshot, another will change their talk title inside a shared Google Doc, and a third will send their AV preferences via a direct message.
The aiDotEngineer portal resolved this by introducing a crucial design choice: completeness as a score, not a gate. Traditional form structures demand full completion before saving, which actively drives users away from the system and back into the chaotic comfort of their email inboxes. A sponsor may possess their vector logo today but won’t have the final abstract for their technical workshop until next week.
The custom portal allowed partial, incomplete drafts to be saved constantly. The user interface displayed completeness as an ongoing score, highlighting exactly which variables were missing. This small design adjustment eliminated hundreds of loose email threads, capturing the "partial truth" directly into the central database without human intervention.
The Machine-Readable Conference (aie.65labs.org/api/v1)
In a landscape increasingly populated by autonomous agents and LLM-driven productivity tools, structuring data solely for human eyes is a major missed opportunity. The team deliberately exposed the entire conference structure via a clean public API endpoint.
By making the schedule, sessions, speaker metadata, and venue geography fully machine-readable and documenting them via OpenAPI standards, the system allowed downstream programs to ingest the conference state effortlessly. Attendees could construct bespoke itineraries via personal LLM assistants, or query the endpoint to filter for highly technical topics like the Model Context Protocol (MCP) or autonomous coding frameworks. Rather than requiring brittle web-scraping scripts, the conference data was structured from day one so that AI tools could natively comprehend it.
Engineering the Workshop Operating System
The true stress test of any technical conference is its workshop track. While main-stage keynotes accommodate large audiences with minimal friction, specialized technical workshops require strict capacity caps, precise attendee vetting, real-time waitlist management, and instant communication loops.
Because standard commercial ticketing platforms rarely expose robust webhooks or the fine-grained APIs needed to manage these hyper-dynamic states, the aiDotEngineer team reverse-engineered the platform's transactional data flows to construct a custom layer directly on top: The Workshop OS (aie-workshops.65labs.org).
+-------------------------------------------------------------------------------+
| THE WORKSHOP OS CORE DASHBOARD |
+-------------------------------------------------------------------------------+
| Session Name | Capacity | Booked | Waitlist | Status | Export |
+----------------------+----------+--------+----------+-------------+-----------+
| LLM Agents in Prod | 150/150 | [150] | (84) | CRITICAL | [CSV] |
| Advanced RAG Systems | 300/300 | [300] | (142) | OVERFLOW | [CSV] |
| Custom Edge Models | 085/100 | [085] | (00) | STABLE | [CSV] |
+-------------------------------------------------------------------------------+
| [Sync Tickets] [Draft State-Based Email] [Toggle Room Cap Overrides] |
+-------------------------------------------------------------------------------+
The Workshop OS unified the developer and administrator experiences into two primary interfaces:
The Attendee View
Upon opening their digital ticket, an attendee was met with a real-time reflection of their schedule: which workshops they were successfully booked into, their exact room locations, and their real-time position on any waitlists. When onsite staff stood at the physical doors of a high-demand session, they did not need to scroll through a clunky master list; they simply scanned the attendee's ticket view to verify access instantly. Because Convex updates reactively, any last-minute cancellations or waitlist promotions propagated to the attendee’s screen within milliseconds.
The Admin Console
The administrative dashboard provided the operational team with a set of powerful, state-driven control buttons:
State-Based Email Campaigns: Instead of exporting static CSV lists of email addresses to external newsletter tools—which become obsolete the moment another attendee updates their preferences—the email engine was directly tied to the database state. If an instructor needed an urgent prerequisite update sent out, the admin team could target a campaign specifically to "individuals currently marked as Confirmed for Workshop X at this exact second," previewing the precise audience delta before dispatching via Resend.
The Capacity Dashboard: This view acted as the mission control room for the physical venue. It monitored scheduled sessions against real-world room constraints, highlighting overflow pressures, speaker gaps, and waitlist lengths. If a particular workshop on coding agents was experiencing massive waitlist volume, the team could visually spot the capacity ceiling and make data-driven decisions to adjust room allocations or shift human traffic before bottlenecks formed on the showroom floor.
Closing the Digital-Physical Loop
As the planning phase concluded and the event transitioned into the physical realm, the utility of this custom software ecosystem became even more clear. Two distinct applications were engineered to bridge the gap between digital data and physical human movement: the Live Navigation Site and the Custom Lead Scanner.
Ambient Guidance: live.65labs.org
When over a thousand attendees converge inside a multi-room venue, cognitive load skyrockets. People are constantly disoriented, asking variations of the same fundamental questions: Where am I supposed to go next? Is this room full? Where is the track on developer tooling happening right now? Rather than deploying physical staff to repeatedly point at printed banners, the team launched live.65labs.org. This progressive web app sat directly on top of the existing, structured schedule data. It acted as an ambient, context-aware compass for the attendee walking between sessions, displaying live maps, current programming, and personalized bookmarked talks. Because the data layer was shared with the Workshop OS, the live site could dynamically flag when a room had hit maximum capacity, gently redirecting attendees to alternative sessions before they walked across the venue.
De-siloing Sponsor Analytics: leads.65labs.org
For corporate sponsors, the primary return on investment at a technology conference is lead generation. The standard industry solution is to lease expensive, proprietary scanning hardware from an external event vendor. This introduces a frustrating data silo: the scanned information sits in an isolated third-party ecosystem, forcing the conference organizers to manually export, clean, and distribute lead lists weeks after the event has concluded.
[Attendee Badge with Custom QR]
│
▼
[Sponsor App: leads.65labs.org] ---> [Real-Time Convex Sync] ---> [Sponsor Dashboard]
│
▼
Instant B2B Analytics
The five-person team sidestepped this entirely by leveraging OpenAI Codex and Cursor to rapidly compile a bespoke lead scanning app. They dynamically generated unique, secure QR code links for every attendee, stored them within Convex, and sent them directly to the badge printing system.
Sponsors were then given access to leads.65labs.org, allowing them to use their own smartphones to instantly scan attendee badges. The scanned QR codes hooked right back into the primary database, immediately enriching the lead data with self-submitted professional metadata like job titles and corporate affiliations. Sponsors walked away with real-time access to their leads via a clean dashboard, and the core team was completely freed from the post-event administrative burden of data cleaning and distribution.
Constrained Delegation: AI Agents on the Distribution Frontlines
The operational stack was not confined strictly to internal databases and front-end surfaces; it extended out into the digital wild for speaker sourcing, partner research, and strategic outreach. To scale their outreach without hiring a fleet of marketing interns, the team deployed Manus AI—a browser-based operations agent—operating under a philosophy of constrained delegation.
Rather than unleashing unconstrained bots to blast automated spam across the web (a practice that actively degrades brand equity), the team positioned the human as the strategic director and the AI agent as the precise operational executor. The human defined the core positioning, established the target parameters, and bounded the tone. The AI agent was tasked with navigating the repetitive, time-consuming browser tasks.
Phase 1: High-Value Target Research
The team instructed the browser agent to execute targeted research campaigns across LinkedIn and X to identify key decision-makers within specific market sectors, such as Developer Relations, Growth, Product Marketing, and developer-focused founders.
Instead of pulled lists from generic databases, the agent performed live, context-aware web research. It evaluated target companies by size, verified active developer engagement, identified the precise local or regional contacts in the Asia-Pacific region, and returned an audit trail complete with names, roles, and verified URLs.
Phase 2: Calibrated Outreach Execution
Moving from research to execution, the agent was deployed to manage initial, personalized outreach loops. It paced its actions naturally to respect platform rate limits, navigating corporate profiles to initiate connection requests and bespoke introductory direct messages.
Crucially, the agent recorded every dead end—noting where direct messages were restricted, where handles were inactive, or where contacts diverged from the required technical criteria. The team didn't spend their evenings manually clicking through profiles; they spent thirty minutes reviewing clean, structured audit reports, stepping into the inbox only when a prospect responded and a high-context human interaction was required.
The Singapore Dividend: Hyper-Efficiency as a Competitive Mandate
The success of a five-person part-time team executing an event of this scale offers a powerful case study for the broader Singaporean economic landscape. As the country balances tight labor constraints with its ambition to remain the premier high-tech gateway to Asia, businesses across all sectors must figure out how to scale their operations without experiencing linear headcount growth.
==================================================================================
TRADITIONAL VS. AI-NATIVE CONFERENCE OPERATIONS
==================================================================================
OPERATIONAL VECTOR TRADITIONAL EVENT AGENCY AI-NATIVE MICRO-TEAM (AIE)
----------------------------------------------------------------------------------
Staffing Model Large agency + on-site armies 5 part-time professionals
Data Management Distributed spreadsheets Centralized reactive backend
Asset Collection Manual email/WhatsApp chasing Self-scoring portal
Sponsor Analytics Siloed third-party hardware Custom integrated web-apps
Outreach Scaling Manual outbound prospecting Constrained browser agents
==================================================================================
What aiDotEngineer Singapore demonstrated is that when a organization transitions from manual operations to an architecture of software automation, the capacity of a single professional scales exponentially. The modern technology stack allows a micro-team to act with the institutional weight of an organization many times its size.
By replacing manual row-matching with automated data validation, and swapping administrative chasing with smart self-service portals, the core team preserved their cognitive energy for what mattered most: curation, experiential design, high-value sponsor relationships, and community building. This is the unsexy, programmatic secret of the AI era: true leverage isn't found in glamorous, fully autonomous systems that try to replace human intuition, but in the deliberate engineering of software systems that eliminate administrative friction at the data layer.
Key Practical Takeaways
For any engineering team, founder, or enterprise operator looking to replicate this hyper-efficient operational model, the design patterns can be distilled into a few core principles:
Centralize State Immediately: Do not permit core business or event data to live across fragmented communication channels. Anchor your project to a reactive, real-time backend (like Convex) from day one to serve as the undeniable ground truth for every downstream application.
Design for Imperfect Data Ingestion: Abandon rigid forms that mandate total completeness. Build user portals that gracefully accept partial truths, displaying completeness as an ongoing score rather than an absolute gatekeeper. This keeps data inside your system and out of chaotic email loops.
Build State-Driven Communication Engines: Never export static CSV files to run email or marketing campaigns. Connect your communication layers directly to your transactional database so that messages are dispatched based on real-time participant state.
Expose Machine-Readable Interfaces: Treat your operations as a platform. Build clean, documented APIs (/api/v1) from the start, ensuring that both human users and autonomous AI agents can instantly comprehend and navigate your structural layout.
Embrace Constrained Agent Delegation: When deploying AI agents for outreach or research, do not automate blind spam. Use humans to set rigorous boundaries, targets, and tones, and let browser-based agents handle the repetitive, manual clicks while generating transparent audit trails.
Frequently Asked Questions
How did the five-person team handle the immense physical demands of the conference on the actual day of the event? While the three months of prep, software tooling, portal management, and backend infrastructure were entirely built by the five-person part-time crew, the team brought on a dedicated group of physical volunteers during the final week and the days of the event. When more than a thousand human beings are physically navigating a venue, you absolutely need hands on the ground to manage registration queues, hand out badges, and handle physical crowd control. The software architecture didn't replace human presence; it ensured that the volunteers were stepping into a perfectly synchronized, error-free operational system.
Why choose a custom-built software stack over established, off-the-shelf event management platforms? The alternative to a custom stack is almost never a single, seamless off-the-shelf platform. In practice, generic platforms are rigid and fail to adapt to specialized technical workflows, such as waitlist management for highly technical workshops or real-time developer profile enrichment. Organizers using standard platforms invariably end up acting as human glue—manually copying and pasting data across ten different spreadsheets, disconnected email services, and isolated scanning hardwares. Building a custom backend layer allows an organization to tailor the software to its exact operational workflow, automating repetitive tasks completely.
What specific role did tools like Devin, Cursor, and Codex play in the software development lifecycle of this project? These AI native tools fundamentally altered the speed of execution. Devin AI was utilized to autonomously scaffold and build out the public-facing elements of the web architecture. Meanwhile, tools like Cursor and OpenAI Codex served as real-time, highly capable coding companions for the team. They were particularly invaluable for writing on-the-fly edge functions, building internal admin views, and rapidly developing the custom lead scanning application while the team was literally on the move between their primary day jobs. These tools shifted the team's role from writing boilerplate code to architecting data flows and validating system logic.
No comments:
Post a Comment