Taskie

Inspiration

Meetings are full of important decisions, ideas, and action items, but it is easy for those details to get lost after the meeting ends. Tasks may be unclear, ownership may be forgotten, and teams often have to manually convert conversations into trackable work.

We wanted to build a practical solution that does more than just summarize meetings. Our goal was to create a system that connects the conversation to verified execution.

That idea became **Taskie — From Conversation → to Verified Execution.

What it does

Taskie is an AI-powered meeting assistant that converts meeting conversations into structured, trackable work.

Users can provide meeting information through:

Live voice recording
Audio uploads
Text or transcript input
TXT and PDF files

Taskie processes the input and uses AI to identify:

Meeting summary
AI-generated notes
Personal notes
Decisions
Action items
Responsible people
Due dates
Priorities
Dependencies
Unresolved questions
Confidence information

Instead of automatically turning AI output into final tasks, Taskie includes a human verification layer. Users can review, edit, approve, reject, add, or delete extracted information.

Approved action items can then become trackable tasks, maintaining a connection between the task, its original action item, and the meeting where it came from.

Taskie also provides dashboards, search and filtering, meeting history, task tracking, analytics, and export functionality.

How we built it

We built Taskie as a full-stack web application.

Frontend

React
TypeScript
Vite
Tailwind CSS
Lucide React

Backend

Node.js
Express
TypeScript
Mongoose

Database

MongoDB Atlas

AI and processing

Gemini API for meeting analysis
Speech-to-text processing for audio
Browser MediaRecorder API for live recording
PDF and text extraction

The application follows a pipeline:

Capture → Understand → Verify → Act → Track

The frontend communicates with our Node.js/Express backend, while the backend handles authentication, database operations, file processing, AI analysis, verification, and task management.

Challenges we ran into

One of our biggest challenges was making AI-generated information useful without treating AI output as automatically correct.

We therefore designed Taskie around human verification, allowing users to review and modify AI-generated decisions and action items before they become final.

We also had to handle multiple types of meeting input, including text, PDFs, audio uploads, and live recordings, while keeping them connected to the same analysis workflow.

Another challenge was maintaining relationships between meetings, action items, and tasks so that users can trace a task back to the conversation that created it.

During development, we also worked through authentication, database connectivity, file processing, API integration, deployment configuration, and production environment variables.

Accomplishments that we're proud of

We are proud that Taskie evolved from a simple meeting summarizer into a complete meeting-to-execution workflow.

Our key accomplishment is the human-in-the-loop verification system, which gives users control over AI-generated results instead of blindly accepting them.

We are also proud of the persistent relationship between:

Meeting → Action Item → Task

This makes it possible to understand not only what needs to be done, but also where that task originally came from.

Building a complete full-stack application with AI analysis, voice input, authentication, database persistence, task management, dashboards, and deployment was also an important achievement for our team.

What we learned

We learned how different parts of a full-stack application work together in a real project.

We gained practical experience with React, TypeScript, Node.js, Express, MongoDB, API integration, authentication, file uploads, audio processing, AI APIs, and deployment.

We also learned that building an AI application is not only about getting an AI model to generate an answer. The surrounding workflow — validation, user control, data persistence, error handling, and usability — is equally important.

Most importantly, we learned how to turn an idea into a working product by dividing the problem into smaller components and integrating them step by step.