How i simplified a complex meeting worflow

Chhavi Kashyap — Sat, 06 Jun 2026 17:50:22 +0000

Building software is often less about adding features and more about removing friction.
When I worked on MeetMind, my primary responsibility was user interface design. MeetMind is an AI-powered meeting memory assistant — it stores everything you know about a professional contact and recalls it intelligently before your next meeting. The goal was straightforward: help users never walk into a meeting unprepared again.
The challenge wasn't collecting information — it was presenting it in a way that felt manageable.

The Product In One Sentence
Type a contact name. Get an AI-generated briefing based on every past interaction you have logged with that person.
Without memory:
User: "Prepare me for Rahul's meeting."
Agent: "I don't have any information about Rahul."
After saving notes:
User: "Prepare me for Rahul's meeting."
Agent: "Rahul needs a React website. Budget ₹50,000. Follow up Monday. Prefers morning meetings."
That before/after is what the entire UI is designed to deliver clearly and quickly.

Understanding the Real Problem
At first glance, it seemed like the interface needed to expose every available feature.
The product generated briefings, stored meeting histories, saved notes, and recalled memories. My initial instinct was to make all of these capabilities highly visible.
The result looked feature-rich but felt overwhelming.
When I stepped back and reviewed the workflow, I realized users weren't asking themselves:
"What feature should I use?"
They were asking:
"What do I need to do next?"
That distinction changed how I approached the design entirely.

Organizing Information Around User Intent
Instead of designing around system capabilities, I started designing around user goals.
Users of MeetMind typically wanted one of two things:

Generate a briefing before an upcoming meeting
Save notes after a meeting just ended

Everything else was secondary.
This observation led to a simpler information hierarchy. The navbar has exactly two items: Briefing and Save Notes — the two actions users actually need, nothing else.
The interface became easier to scan because users no longer had to process every available option before taking action.

The Visual Direction
Most AI tools default to dark themes and technical aesthetics.
I went the opposite direction — a warm cream background, deep crimson navigation bar, serif typography, and a professional hero image. The goal was to make MeetMind feel like a tool that belongs in a real professional environment.
The hero copy lands the value proposition immediately:
"Never walk into a meeting unprepared. MeetMind remembers every conversation, follow-up, and preference — so you always know exactly what to say."
Users understand the product within three seconds of landing on the page.

Reducing Visual Noise
One challenge with meeting-related products is the amount of content they generate.
AI-generated briefings, saved notes, timestamps, and historical records can quickly compete for attention.
To address this, I focused on reducing visual noise rather than adding more organizational elements.
Some of the changes included:

Increasing whitespace between content sections
Creating clearer visual separation between the briefing output and the notes input
Using consistent typography for hierarchy
Reducing unnecessary labels and repeated metadata

None of these changes were dramatic individually, but together they made the interface feel less crowded.
The lesson was simple: readability often creates more value than additional functionality.

Designing Around AI-Generated Content
An interesting challenge was that the content itself was unpredictable.
Unlike traditional applications where text fields have relatively consistent lengths, AI-generated meeting briefings can vary significantly. Some contacts have one saved note. Others have ten.
Designing for both cases required flexibility.
I avoided layouts that depended on fixed content sizes and instead focused on responsive containers that could scale naturally. This prevented situations where longer briefings would dominate the page or push critical information out of view.

The Frontend Implementation
The entire frontend is built with pure HTML, CSS, and JavaScript — no frameworks, no build pipeline.
The UI communicates with the Flask backend using the browser's native fetch() API:
javascriptasync function generateBriefing() {
const contact = document.getElementById("contact").value.trim();

briefingBox.innerHTML = 'Generating briefing...';

const response = await fetch("/get_briefing", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ contact: contact })
});

const data = await response.json();
briefingBox.textContent = data.briefing;
}
One async function. No dependencies. Instant feedback to the user.
The loading state — showing "Generating briefing..." in yellow while waiting — was a small but important detail. AI responses take a few seconds. Without visual feedback, users assume the button did nothing and click again.

What Didn't Work
Not every design decision was successful.
One early approach attempted to surface too much information on a single screen. The intention was to reduce navigation, but the result increased cognitive load.
Users had access to everything at once, yet finding specific information became harder.
This reinforced an important principle:

Reducing clicks doesn't automatically improve usability.
Sometimes a cleaner structure with clear navigation creates a better experience than placing everything on one page.

Lessons I Took Away

Design for the next action Users rarely explore software feature by feature. Most arrive with a specific task in mind. Interfaces become simpler when they support that task directly.
Information hierarchy matters more than volume Adding more information is easy. Helping users understand which information matters most is significantly harder.
Flexibility is essential when working with AI AI-generated content introduces variability that traditional interfaces don't have to handle. Layouts need to accommodate both short and long outputs gracefully.
Simplicity requires deliberate decisions Simple interfaces aren't created by removing effort. They are created by making careful choices about what deserves attention and what doesn't.

The Full Tech Stack
LayerTechnologyFrontendHTML, CSS, JavaScriptBackendPython FlaskMemoryHindsight by VectorizeAIGroq llama3-70bDeploymentRender
The memory layer is what makes MeetMind genuinely different from a standard chatbot. Hindsight stores meeting notes as semantic embeddings — so recalling "Rahul" surfaces everything related to Rahul even if the note says "the React client from Monday."

Try It
Live app: https://meetmind-iatt.onrender.com
Source code: https://github.com/chhavi523/MeetMind
Hindsight memory layer: https://hindsight.vectorize.io
Vectorize agent memory: https://vectorize.io/what-is-agent-memory

Closing Thoughts
My work on MeetMind focused on user interface design, but the most valuable lesson wasn't about colors, spacing, or components.
It was about understanding how people interact with information before a meeting begins.
The biggest improvements came from organizing the experience around user intent rather than product features. Once that shift happened, many design decisions became easier.
A cleaner workflow, clearer hierarchy, and better prioritization ultimately did more for usability than adding another feature ever could.
When an interface feels complicated, the answer is often not to add more — it is to simplify what already exists.

DEV Community: Chhavi Kashyap

How i simplified a complex meeting worflow