The Story Behind Meetily

The Moment It Started

We were wrapping up a call with a potential client. Sensitive stuff - pricing, roadmap, competitive positioning. The kind of conversation you don't want floating around on someone else's servers.

After the call, I opened our meeting tool to grab the notes. And then I actually read the privacy policy.

Our entire conversation had been uploaded. Stored on infrastructure we didn't control. Potentially used for model training. And if we ever cancelled our subscription? The data retention policy was vague at best.

I closed my laptop and thought: We're paying for this?

The Search

We tried other tools. Same story, different branding.

Every product we evaluated had the same model: your audio goes to their cloud, gets processed on their servers, stored in their database. You get a nice interface. They get your data.

Some had better privacy policies than others. But "better" still meant trusting someone else with our client conversations.

What we actually wanted was simple:

• Keep recordings on our own devices - not someone else's servers
• Choose our own AI providers - or use local models if we needed maximum privacy
• Export and delete freely - our data, our rules
• No lock-in - if we stop using the tool, we keep our history

We searched. We asked around. Nothing fit.

The Decision

We could keep searching. Or we could build what we needed.

We chose to build.

The Embarrassing First Version

Let's be honest about what v0.0.1 looked like:

• macOS only (we developed on Macs)
• Required CMake, Python 3.10+, and a bunch of terminal commands
• Two separate processes - frontend and backend - that you had to run manually
• Crashed sometimes. Lost transcripts occasionally.

Our own team complained. "Can't you just make an installer?"

But it worked. Meetings stayed on our machines. We could delete them anytime. No data left our devices unless we explicitly chose to use a cloud API.

It solved our problem. That was enough for us.

Then We Open Sourced It

We figured: if we needed this, maybe others did too.

We pushed the code to GitHub. Added a README. Expected maybe a few dozen developers to try it.

Within weeks, the stars started climbing. Issues poured in. Feature requests we hadn't considered.

People asked for:

• Windows support (our first release was Mac-only)
• Meeting history that persisted between sessions
• Pre-built installers (not everyone wants to compile from source)
• A unified app (no separate backend server)
• Custom AI endpoints (bring your own API keys)

We listened. We shipped.

What Changed (And What Didn't)

Today, Meetily looks different than that first embarrassing version:

• Windows & macOS - single installer, no dependencies
• 61,000+ downloads - from that first handful of users
• 9,700+ GitHub stars - people actually use this
• Community and Pro editions - free open source core, paid features for those who need them

But some things stayed exactly the same:

Your meetings stay local. SQLite database on your device. Audio files on your machine. If the app crashes, your data is still there - audio is the source of truth, and we can recover from it.

You choose your AI providers. Transcription runs locally with Whisper or Parakeet. For summarization, use local models for maximum privacy, or connect your own API keys to Claude, OpenAI, or Groq. We document each provider's policies so you can decide.

Export, delete, backup - anytime. PDF, Word, Markdown. Full database exports. No "please contact support to delete your data" nonsense.

Open source. The code is on GitHub(opens in new tab). MIT licensed. Verify it yourself, build it yourself, self-host it yourself.

What We're Still Figuring Out

We're not done. A few things we're working on:

Better local summarization. Local models don't match cloud quality yet. We're working on it - privacy shouldn't mean compromising on results.

More pluggability. Transcription runs locally only right now. We're planning to make that pluggable too, for users who need specific accuracy levels.

Features users ask for. Speaker identification. Custom templates. Calendar integration. We build what people actually request, not what we assume they want.

Why This Matters

There's a reason we're telling this story.

Every week, we see another AI tool launch with "privacy-first" in the tagline. Most of them upload your data to their servers and call it a day.

We built Meetily because we actually needed it. The architecture - local storage, pluggable AI, complete data control - exists because we refused to accept the alternative.

You shouldn't have to choose between useful AI and owning your data. That's the point.

Meetily is built by Zackriya Solutions(opens in new tab). The source code is available on GitHub(opens in new tab).