Vitalis

System Architecture Flowchart

Inspiration

Our idea for Vitalis emerged from seeing how difficult it is for nurses to monitor so many tasks at one. Our goal is to build connected, real-time, “smart” systems, especially when hardware, sensor, and software components must all work together. We wanted to tackle the friction of going from physical / sensor inputs to useful insights in a seamless way. At HackNYU, we decided: let’s build something end-to-end that closes the loop, hardware through software, so that users can interact intuitively rather than wrestle with integration.

What it does

Vitalis is a unified platform that links physical IoT/hardware (for example an ESP32 or other sensors) with a web frontend and backend service, enabling:

Data collection, from the sensor/hardware side in the server/ folder.
Real-time visualization/interaction, the frontend shows live updates, status, or metrics.
Web-based user interface, built with modern web tools so users can interact via browser. Backend logic / API — in server/, to receive sensor data, process it, and serve it to the frontend (or perhaps trigger actions). In short: Vitalis gives users insight into their connected device, letting them monitor, control, or analyze physical inputs through a clean web interface.

How we built it

Here’s a rundown of our tech stack and process: Frontend: Built using a Vite + TypeScript setup and styled with Tailwind. Backend: The server/ folder hosts a Node.js/TypeScript server that handles sensor data ingestion, APIs, and possibly real-time communication. Hardware integration: Using the ESP32 and integration docs, we configured the hardware side to emit data, connect over WiFi or BLE, and link into the backend. Deployment/Infra: We used Amplify for hosting frontend/backend or both. Development workflow: We kicked off with wireframes of what users should see, created the ESP32 prototype, built the backend API to accept the data, then connected the frontend UI to show the sensor data in real time and allow interaction. We iterated quickly, refined UI styling with Tailwind, and ensured the hardware component was reliably streaming.

Challenges we ran into

Hardware-software bridging: Getting the ESP32 to reliably connect, send data, and align with the backend API took longer than anticipated. Dealing with network reliability, sensor calibration, or firmware constraints slowed us. Time pressure: With hackathon time constraints we had to make trade-offs: some features (like full analytics or user accounts) got deferred. Real-time data handling: Ensuring that incoming sensor data flows smoothly into the backend and gets reflected in the UI without lag or errors posed architectural decisions (WebSockets vs polling, data buffering, error handling). UI/UX polish: While tailwind helped, creating a smooth UI that maps complex sensor data into an intuitive user experience added overhead; we had to prioritize key elements. Team coordination & integration: With hardware, firmware, backend and frontend being worked on separately, aligning interfaces and protocols (e.g., data schema for sensor, REST vs WebSocket endpoints, UI expectations) required extra sync.

Accomplishments that we're proud of

We built a fully integrated system (hardware → cloud backend → web frontend) within 24hr timeframe, achieving end-to-end functionality rather than just prototypes. We delivered polished UI styling + a clean user interface with modern web stack (TypeScript + Vite + Tailwind) that users can actually navigate and understand. We documented the hardware integration clearly (ESP32 docs, quick-start guide) so that others can replicate or extend the system. We deployed a live demo / hosted version (via Amplify or similar) such that others could test without local setup, making the project accessible. We validated the idea: feedback from peers/mentors indicated this kind of system fills a gap in making IoT data readily accessible via web, which bolsters the value proposition of Vitalis.

What we learned

We deepened our understanding of embedded/hardware integration: firmware development on ESP32, connecting to cloud services, and handling real-world sensor constraints. We strengthened our full-stack development skills: backend API design, frontend architecture (Vite/TypeScript), and cross-layer communication (firmware ↔ backend ↔ frontend). We improved our rapid prototyping / hackathon workflow: how to split tasks among hardware, backend, and frontend teams; where to cut features; how to maintain momentum. We enhanced our appreciation for user-centred design: creating a UI that doesn’t just display raw sensor data but presents it meaningfully to users. We got practical experience in deployment and cloud hosting, thanks to using Amplify for a live demo, which taught us about CI/CD, hosting static sites plus backend functions, and environmental configuration.

What's next for Vitalis

Analytics & insights module: Beyond real-time monitoring, we’ll add historical data tracking, trend detection, and recommendation engine to turn raw data into actionable insights. Open-source and community contributions: We’ll open the project further, document APIs and hardware interfaces, invite community to build plugins or extensions, and grow an ecosystem around Vitalis. Commercialization / real-world deployment: Explore real-world pilots (e.g., smart-home, industrial sensor monitoring), partnerships or a freemium model that helps scale the platform sustainably.