Zylo

• 

  Main Dashboard

• 

  Resources Page

• 

  Appointments Page

• 

  Calendar

Inspiration

Healthcare scheduling is still surprisingly manual and fragmented for how advanced medicine has become. Even in modern hospitals, coordination often relies on phone calls, emails, and disconnected systems that don’t communicate with each other. We were inspired by how much inefficiency comes from coordination rather than medical care itself, patients waiting not because treatment takes long, but because systems don’t align: rooms aren’t ready, labs aren’t synced, and departments have independent schedules. Zylo was created to fix this hidden bottleneck in healthcare: the scheduling layer that quietly impacts everything from patient experience to hospital efficiency.

What it does

Zylo is an intelligent healthcare scheduling platform that dynamically coordinates patients, providers, departments, and resources in real time.

Instead of static booking, Zylo:

• Builds optimized schedules across multiple departments in one flow (e.g., lab -> imaging -> specialist)
• Detects and resolves scheduling conflicts
• Predicts no-shows and recommends safe overbooking levels
• Re-optimizes schedules in real time when delays occur
• Fills gaps using smart waitlist prioritization
• Manages constraints like rooms, equipment, staff, and timing dependencies

In short, Zylo turns scheduling from a manual coordination problem into an automated, continuously optimizing system.

How we built it

We built Zylo using Claude Design and Claude Code, which helped rapidly prototype the interface. The prototype was implemented using, JavaScript, HTML, CSS and JSX. Claude Design helped shape the dashboard layout and user experience, while Claude Code was used to generate the scheduling logic and UI structure.

Challenges we ran into

One of the biggest challenges was designing a dashboard that shows a high amount of operational information without overwhelming the user.

Healthcare scheduling involves many moving parts at once:

• Multiple departments running in parallel
• Doctors with overlapping schedules
• Limited rooms and equipment
• Time-sensitive dependencies between appointments

Balancing all of this in a single interface required prioritizing what information shown in each view.

Another major challenge was modeling relationships between departments, doctors, equipment, and rooms in a way that stays flexible but still enforces real-world constraints. For example, a room or MRI machine can become a bottleneck, and a delay in one department cascades into others. We also had to think carefully about how to keep the system understandable for coordinators who are used to manual scheduling tools.

Accomplishments that we're proud of

We successfully built a working prototype of an intelligent scheduling system that simulates real hospital coordination across multiple constraints.

Key accomplishments include:

• A functional prototype built with Claude Code in JavaScript, HTML, CSS, and JSX
• A unified dashboard that brings together departments, doctors, rooms, and equipment
• Early conflict detection logic for scheduling overlaps and resource constraints
• A design approach that balances information density with usability
• A system concept that demonstrates real-time scheduling adaptation

Most importantly, we turned a complex hospital operations problem into a working interactive system rather than just a concept.

What we learned

We learned that the hardest part of healthcare scheduling is not logic, it’s information design.

Even if a system is powerful, it fails if users cannot quickly understand:

• What is happening
• Where conflicts exist
• What needs attention

We also learned how difficult it is to model real-world healthcare systems, where everything is interconnected and small changes can cascade across departments. Finally, using Claude Design and Claude Code showed us how AI-assisted development can dramatically accelerate prototyping of complex systems.

What's next for Zylo

Planned next steps:

• Improve dashboard UX to better balance detail and clarity
• Add real-time scheduling optimization and rebalancing logic
• Expand support for predictive no-show modeling
• Integrate with real hospital systems
• Build patient-facing scheduling and notification tools
• Automate pre-appointment paperwork and patient intake to reduce administrative delays and prevent scheduling bottlenecks
• Conduct pilot testing with clinics or small hospital departments

Built With

• claude
• css
• html
• javascript
• jsx