Building a Wrapper that Lasts.
The engineering philosophy, product instincts, and growth loops behind Granola's unlikely rise, and the playbook every startup operator should learn from.
I still remember it like it was yesterday - I was sitting in the verandah of my well-lit Bangkok hotel room, showing my new Swedish friend Max a bunch of AI apps I’d found on the App Store. We were both startup and tech nerds as we bonded over a delicious plate of Pad Thai.
At the time, I was working with Arcads AI, studying how B2C apps were minting money by building thin layers on top of foundational LLM models.
I was surprised to learn that some were pulling in millions of dollars a year. And at first instance, they looked dead stupid simple to build. Amazed by their simplicity, I showed them to my friend.
Max looked at my screen, then looked at me, and said: “Dude. It’s just a wrapper.”
And his reaction captured something I’ve heard over and over in entrepreneur and startup communities ever since. The idea that building a wrapper is somehow beneath you. That real builders make real things.
I disagreed with that trope, and I let my feelings known to Max, as I quoted Arvind Srinivas who put it best - “everything is a wrapper.“
McDonald’s wraps beef, bread, and condiments into a Big Mac. Spotify wraps MP3s into a discovery engine.
Every product takes something that already exists, adds a layer of context, design, or workflow, and resells it as something new.
We’ve been doing this forever. The question was never whether to wrap. It’s knowing what to wrap, and how well.
In the 1880s, America embodied this spirit to the tee. The 1880s saw the introduction of two revolutionary new technologies - electric power and the internal combustion engine. Electricity gave birth to electric tools for factories and homes such as elevators, electric railways, washing machines, refrigerators and air conditioners. The internal combustion engine gave rise to cars, trucks and buses.
None of these inventions could be attributed to America. It was Michael Faraday, an Englishman who produced the first electric generator, while in 1879, it was the German, Karl Benz, who developed the first internal combustion engine.
America’s genius lay in making these core innovations more user friendly, producing companies that can commercialize these innovations, and developing techniques for running these companies successfully.
I see no reason why history won’t repeat itself.
Companies like Harvey AI, Cursor have successfully built products on top of foundational models that are worth billions, much like how Henry Ford made an internal combustion engine wrapper back in the day.
The “it’s just a wrapper” crowd makes a rather simple argument - building on top of someone else’s model means your core technology isn’t defensible. OpenAI ships a new model and your moat shrinks overnight.
That’s true. But only partially.
Foundational models are better, faster, and cheaper than they’ve ever been. The value has shifted up the stack, to whoever can apply these models most effectively to specific, high-stakes workflows.
Low-frequency and low-stakes tasks will get absorbed by general-purpose tools like ChatGPT. Nobody needs a dedicated app to summarize an email. Gemini can nail that pretty well.
But professional, high-stakes workflows such as coding, sales, recruiting, legal review, client meetings will be owned by focused tools that go ten layers deep on a single use case.
Cursor didn’t win because it invented a new AI. It won because it rebuilt the entire coding workflow around AI from the ground up.
The wrapper isn’t the product. The workflow is the product.
Few products illustrate this better than Granola - an AI notepad built specifically for meetings.
Granola doesn’t try to replace how you think. It is designed to augment it. You still take notes in your own words during the call. Granola quietly runs in the background, capturing the transcript. Afterward, it blends your notes with what was actually said, and turns it into something clean and usable. The AI fills in the gaps; your thinking shapes the output.
This is the tension at the heart of every good AI product: convenience vs. specialization. Most people will default to one general tool - ChatGPT, Gemini, for 80% of tasks, the same way everyone uses Google even when a specialized search engine might do better. Habit wins.
But professionals like designers, engineers, salespeople, founders, investors, will always need tools that make them genuinely 10x better at the thing they spend most of their time doing. Not “okay at everything.” Great at this.
That’s the playbook - Enter via a specific use case that matters to a specific type of person. Build an AI-augmented workflow around it. Go far enough, and the line between software and service starts to blur.
Granola’s goal is to become the “Jetpack for the mind” - as they seek to redefine what it means to be a knowledge worker in an AI-native world.
In March of this year, Granola raised $125M in a Series C at a $1.5bn valuation, led by Index Ventures and Kleiner Perkins, with participation from Lightspeed, Spark and NFDG.
They have customers from established companies likeVanta, Gusto, Thumbtack and Asana to fast-growing startups like Cursor, Lovable, Decagon and Mistral AI.
In the rest of this essay, I’ll show you how Granola executed this, their vision, and the playbook to build an AI wrapper like Granola with a real moat.
The Origin Story - How did Granola start?
In June 2022, Chris Pedregal left Google with a hunch. He’d been playing with GPT-3 (remember that?) and felt something fundamentally different was happening with AI.
He didn’t know exactly what to build yet, but he knew he needed a co-founder who was both technically strong and deeply thoughtful about what AI-native interfaces could actually look like.
That search led him to Sam Stephenson, who was embedded in the “tools for thought” community where people obsessed over how software could extend human thinking rather than just automate it.
Together, they were well-positioned to build something interesting. The harder question was: what?
When foundation models started exploding in capability, it wasn’t obvious which problems were best suited for them. Chris and Sam weren’t the only ones confused. This was the era when AI writing tools, sales assistants, and customer support bots were all racing to be the category winner, and everyone was pattern-matching on whatever seemed to be working.
Granola’s approach was almost Darwinian: build many things, let most of them die, and pay close attention to what survives. They cycled through prototype after prototype - AI journaling apps, coding assistants, tools for personal knowledge management. None of them clicked. But each failure narrowed the search space.
What Actually Sucks About Your Job?
Chris and Sam spent weeks wandering through people’s workflows, asking one open question: “What actually sucks about your job?”
The answer that kept surfacing, across roles and industries, was meetings. Every call left behind a pile of low-energy, time-consuming follow-up work: notes to clean up, emails to send, CRM fields to update, action items to track. The kind of work that nobody finds meaningful but everybody has to do.
“For people whose jobs revolve around meetings, the work just stacks up,” Chris observed.
The more they dug in, the clearer it became - Meetings were a uniquely attractive beachhead.
They have a defined structure: clear start times, clear end times, a natural moment of transition when the real work begins. And they have virality baked in: when one person in a call uses a new meeting tool, everyone else on the call is exposed to it.
What they were really building wasn’t a notes app. It was a tool that sits inside your meetings, quietly, and clears the wreckage afterward, so the people whose entire jobs run on conversations can spend less time on admin and more time on the work that actually matters.
By March 2023, Chris and Sam founded Granola with a singular mission: use AI to tame meeting hell.
The road to PMF - Experiments, Habits, and the Art of Pruning
Early Granola wasn’t a clean vision executed well. It was a long, iterative search of six to nine months of running experiment after experiment, a year-long beta with 150 users, and more discarded features than shipped ones. What came out the other side was a set of principles that shaped every decision they made as they found PMF.
Three of them stand out.
Principle #1: Balance Functionality with Simplicity.
The first version of Granola looked great in demos.
The original interaction model was real-time AI augmentation: as you spoke, the AI wrote your notes live, right in front of you. Investors loved it. But when real users sat down with it for actual calls, something broke.
People stopped listening to the meeting. They watched the AI instead: reading along, catching errors, nudging it back on track.
In a cruel tryst of irony, the very tool that was designed to reduce cognitive load was adding to it.
That failure contained the key insight: the interface had to disappear during the meeting, not perform.
What emerged from a year of iteration looks almost aggressively simple. It looks like Apple Notes. You type during the meeting - fragments, shorthand, whatever comes naturally. Granola records and transcribes in the background. When the call ends, your rough notes quietly transform into something polished and complete, on the same page, without you touching anything.
Once they found that core interaction, they cut roughly 50% of everything they’d built - this meant features that demoed well but weren’t robust in daily use were scrapped.
“The hard thing was figuring out how to let users get the stuff they care about in a way that feels natural and effortless,” Stephenson explained. “We really can’t put too many buttons in front of you when you’re in that situation - you don’t have the brain space for it.”
Which brings us to Principle #2:
Principle #2: Be Selective About the Challenges You Take On
Building fast is easy. Knowing what not to build is the hard part.
Early on, real-time transcription accuracy was poor. The obvious move would have been to invest in building a proprietary transcription engine and to own the problem end to end.
Granola didn’t. They doubled down on better note summarization and waited for transcription technology to mature on its own. The same restraint shaped decisions around multilingual support, retrieval-augmented generation, and ultra-long meeting capture. All real problems. All deliberately deferred.
“We have to be quite selective about the challenges we bite off and the ones we choose to leave alone. A lot of the game for us has been picking our battles, knowing what to innovate on, and where we needed to wait for the technology to get better.” -Sam Stephenson.
This is a harder discipline than it sounds. When the problem space is vast and the team is small, the temptation is to chase every edge case, fix every gap, ship every feature that users ask for.
What Granola understood was that restraint is a form of focus. And focus, at the early stage, is everything. A small team that tries to solve ten problems solves none of them well. A small team that solves one problem completely owns it.
The problems you choose not to solve are as important as the ones you do.
Principle #3: Optimize around a key metric
Most early-stage teams track whether users like their product. Granola tracked something harder: whether users needed it.
They built a dot-plot chart for each beta user showing how many meetings they’d used Granola in, day by day. This focus shaped everything. A feature that spiked engagement once was irrelevant. What mattered was whether Granola had become part of the ritual of working and became as habitual and invisible as opening your laptop.
This is why they also paid close attention to who they were selling to. VCs became their early customers. The logic was straightforward: VCs spend enormous portions of their lives in back-to-back meetings, taking notes that feed directly into investment decisions and portfolio relationships. High volume, high stakes, and highly habitual. If Granola could embed itself into that workflow, it would stick.
It did. The product spread organically through Lightspeed, Lux Capital, Benchmark, Sequoia, Accel, USV, Firstminute, and Betawork. And word spread through the oldest distribution channel there is: someone in a meeting saying “have you tried this?” VCs shared it with founders. Founders shared it with their teams. It became, as one early user put it, the worst-kept secret in the valley.
Habit, once established, became its own moat.
What does Granola do?
When I downloaded Granola for the first time, I was impressed with its simplicity. I downloaded a DMG file, completed the onboarding, and I found the Granola icon pinned on my navbar on the top. It is always there in the background, and it loads automatically when I open my computer each day.
It has access to my calendar, and tracks all the meetings that I have coming up - it reminds me to join the meeting 5 minutes before, and a Granola meeting notes document opens up as it transcribes the audio inside the meeting.
The cool part that I loved was that there were no bots joining the meeting - I always found the idea of bots joining meetings pretty invasive. Within Granola, there was nothing of the sort. It was almost invisible and was quietly doing its thing in the background allowing me to focus on the meeting.
At any time, I could take notes within the Granola doc - rough notes or ideas that I thought were interesting, while the transcription kept happening in the background.
When the meeting was finally over, Granola automatically summarized the conversation for me. I could also choose different templates (like a sales call or a customer discovery call) depending on my use case and get a summary from that POV. I could then chat via AI with the meeting, ask questions to it, and retrieve specific information and ask it to do stuff with the context loaded in. If I wanted, I could send the link to my coworkers or send them a message on Slack without leaving Granola.
I can also organize these meetings into folders, and I can then chat with these folders and retrieve information from that specific folder. I can also prompt Granola to take actions on my behalf like sending an email or creating a list of todos. Slowly I began to see the promise of Granola and began to envision it as having my own personal and professional knowledge and workflow tool.
The Interface: Familiar by Design
The product looks like Apple Notes. That’s not an accident.
Every design decision in Granola has been made to reduce friction at the moment of highest cognitive load, when you’re in a meeting, trying to listen and think and capture at the same time.
The interface is minimal, uncluttered, and immediately familiar. There are no buttons competing for your attention. Nothing that requires you to learn a new mental model.
The Human-in-the-Loop Difference
Granola’s philosophy is that people don’t want replacement. Rather what they want is leverage. They want the work to still feel like it came from them. Full AI automation sounds appealing in theory but in practice, people disengage, the output feels generic, and the notes don’t reflect how you think about what happened.
So Granola keeps the human in the loop, deliberately. You take notes during the meeting in your own word, and when the call ends, it takes your rough notes and makes them significantly better: filling the holes, fixing the typos, adding the context you missed, sharpening the structure.
You can see exactly what AI wrote, verify it against your memory of the call, and put your own voice back in wherever the output doesn’t sound like you. The AI takes you 80–85% of the way. The last stretch is yours.
Critically, you can trigger different templates based on your conversation - for example, you can trigger a “customer demo call” recipe which will create notes from that POV. Likewise for a sales call, or a product feature request etc.
This is what people talk about when they tell someone else about Granola. Not the transcription, not the summarization - the notes are just better. It’s a deceptively simple value proposition that turns out to be genuinely hard to replicate.
From Notes to Knowledge: The Folder Layer
Where Granola starts to become something larger is in what happens after the meeting.
Notes and meetings can be organized into folders - a folder for sales calls, one for customer conversations, one for investor updates, one for team standups. Each folder becomes a shared, searchable repository of everything that’s been discussed in that context. And you can chat with each folder directly, asking questions and getting answers grounded in the actual conversations that happened.
This is the shift from tool to platform. A single meeting note is useful. A folder containing six months of sales calls, with full context on every conversation, every commitment made, every objection raised - that’s a different kind of asset. It compounds. The longer you use it, the more valuable it becomes.
Granola describes the long-term vision as an IDE for knowledge workers: a single workspace where the most important context in your professional life lives, is searchable, and can be acted on. Not a place to store information passively, but a place to work from actively.
Recipes: From Note-Taker to Agent
There’s a quieter capability in Granola that points toward something bigger: Recipes.
Recipes are triggered workflows & prompts you set up once that Granola executes on your behalf after a meeting. Draft the follow-up email. Pull out the action items. Populate the CRM field. Generate the summary for the team Slack. Things that used to live on your post-meeting to-do list, now handled before you’ve even closed your laptop.
It’s a subtle but important shift. For most of its interactions, Granola augments what you do better notes, richer context, smarter search. With Recipes, it starts acting for you. The mundane, low-judgment work that accumulates after every call gets offloaded. You’re freed up for the work that actually requires you.
This is the first clear signal that Granola is building toward something more agentic. The meeting is no longer just a thing to be captured but rather it’s a trigger. Context flows in, actions flow out, and Granola sits in the middle as the orchestration layer connecting what was said to what needs to happen next.
The implications compound quickly. Once Granola is deeply integrated with the tools a team already uses - CRMs, project trackers, communication platforms - it becomes less of a note-taking app and more of a workflow bridge.
Lightspeed’s Mike Mignano believes that Granola has an edge in this space because of its interface and user experience.
“Since the start, the company has had the right mix of AI transcript and human control of taking notes. Now that they are building context across the meetings and making the notes shareable, the product has become stronger. With these features, Granola will have long-term context for users and teams, kicking off network effects for the startup”
The transition from vertical tool to horizontal platform usually happens gradually, then suddenly. Recipes feel like the gradual part.
The Context Layer: APIs, MCPs, and the Everywhere Strategy
A note that lives only inside Granola is useful. A note whose context can flow into every tool a knowledge worker already uses is something categorically different.
This is the bet behind Granola’s API and MCP strategy and it’s one of the most underappreciated moves the company has made.
Granola now offers a personal API, letting individuals programmatically access their own notes and notes shared with them. For teams on enterprise plans, an admin-level API unlocks the full stack of team conversation context - every call, every decision, every commitment made across the organisation, queryable and actionable from outside the Granola interface. Alongside this, an updated MCP lets users surface notes from folders and shared spaces directly inside any AI tool that supports the protocol.
The practical upshot: your Granola context can now show up inside Claude, ChatGPT, Lovable, Figma Make, Replit, Manus, v0, Bolt.new, and a growing list of partners. You’re building a product in Replit and want to pull the context from your last three customer calls? It’s there. You’re using Claude to draft a proposal and want it grounded in what was actually said in the discovery meeting? Also there.
This matters because of what agents fundamentally need to do meaningful work: context. Without knowing what was said, what was decided, and what was promised, an AI agent is operating in the dark - capable of generating output but not capable of generating relevant output. Granola’s context layer solves that problem. It makes meeting intelligence portable, so the most valuable information from your working life isn’t trapped in one app.
The distribution logic here is also worth noting. Every integration is a new surface where Granola’s context proves its value, and a new reason for someone who isn’t a Granola user to become one.
A developer who encounters Granola context inside their Replit workflow, or a designer who sees meeting notes surfaced inside Figma Make, didn’t arrive through a marketing funnel. They arrived because the product embedded itself into the tools they were already using. That’s product-led growth operating at the infrastructure level.
The long game is clear: Granola wants to be the context layer that sits beneath the entire knowledge worker stack. Not the tool you open. The layer that makes every other tool smarter.
How Granola builds Granola:
Most engineering advice is about building things that survive. Write clean code. Separate your concerns. Build a test suite. Invest in abstractions that scale. It’s sensible advice for a company that knows what it’s building.
Granola didn’t know what it was building. So they threw out the rulebook and took their inspiration from somewhere unexpected: evolutionary biology.
541 million years ago, something extraordinary happened in the fossil record. In a geologically brief window, the number of complex animal forms exploded. Thousands of new species appearing, competing, and mostly dying out. The few lineages that survived went on to dominate life on Earth for hundreds of millions of years. Biologists call it the Cambrian explosion.
Granola’s engineering team looked at that story and saw the best startup playbook they’d ever encountered. The whole question became: how do you build software that can evolve the same way?
Their answer organized itself around three principles: make the code friendly to mutation, evaluate variants in parallel, and make bad versions easy to kill.
#1: Write code that's easy to change, not code that's easy to admire.
Clean code is code that’s easy to understand. Evolvable code is code that’s easy to change. At the early stage, Granola decided these were different things and chose the second.
That meant keeping everything in one big codebase rather than splitting it into microservices, modules, or carefully separated layers. One large, interconnected blob is faster to change than many small pieces that all have to coordinate. As they put it: your professor isn’t here to grade you anymore. It’s okay to keep everything in one file.
It also meant deliberately allowing copy-paste code over shared abstractions. Conventional engineering wisdom says copy-paste is bad - it creates duplication and inconsistency. But abstraction creates dependencies: change the shared function, and everything that relies on it breaks. Copy-paste code lets you change one part without touching anything else.
Nature figured this out long ago. Biologists call it Williston’s Law: nature loves to copy-paste and edit. Take a versatile structure like a leg, a tooth or a fin - duplicate it many times, give each copy room to specialize, then let selection kill off the ones that don’t work. The survivors are more adapted than any single carefully designed structure could have been. Granola was doing the same thing with code.
#2: Don’t Broadcast. Distribute.
Most software distribution is sequential. You build v1, ship it to everyone, collect feedback, build v2, ship that. One version in production at a time. If v1 was a mistake, every user is living with that mistake simultaneously.
Granola broke this constraint with a simple decision: distribute via a .dmg file rather than an app store.
The implication was larger than it sounds. Because they weren’t publishing through an app store, they could cut a new build and send it to a single user overnight, with no approval process, no public changelog and no announcement. Different users could be running radically different versions of the product at the same time. Reality was selecting the better variants in parallel, the same way natural selection evaluates competing species simultaneously rather than one at a time.
This is what allowed them to run the kind of experimentation they needed. Different features, different interaction models, different UI flows all live simultaneously, all being evaluated by real users, none of them locked in.
#3: Avoid Everything That Keeps Bad Versions Alive
Without death, natural selection doesn’t work. An organism that can’t die can’t be replaced by something better. The same is true of software but most conventional startup advice accidentally makes software immortal.
Landing pages make versions immortal. They promise specific features and flows that users expect to find. Documentation does the same. Blog posts, tutorials, marketing materials, API contracts, all of them create references that pressure you to keep a specific version alive long after you’ve learned it’s wrong.
Granola’s response was radical: avoid all of it. No public launch. No landing page. No documentation. Manual onboarding only, to a small, carefully chosen group of target users. Every version that didn’t work could be killed instantly - no PR fallout, no user expectations to manage, no documentation to update. The bad variants just disappeared.
This is the counterintuitive flip side of “launch early and often.” Users keep software alive. The more people depending on a version, the harder it is to change. Granola deliberately minimized that pressure during the period when they needed to change the fastest.
#4: Launch with Less
When Granola finally launched publicly in spring 2024, they removed 50% of the features they’d built.
That number deserves a moment. After months of Cambrian-style experimentation with thousands of mutations, dozens of variants, feature after feature built and evaluated and discarded, they shipped half of what they had. Everything that had been demo-good but not daily-use great got cut.
“If you add 50 buttons in there with new features,” Chris Pedregal said, “you kind of kill the golden goose.”
The messy, evolutionary, copy-paste, one-blob approach was how they earned the discipline to know what to cut. You can’t remove the right 50% until you’ve built and tested the wrong 50% first.
How Granola grows
Granola has grown its user base 10% every week since launch. To understand what that means in practice: at that rate, the product roughly doubles every seven weeks. The founding team hasn’t disclosed absolute user numbers, but the growth rate itself tells the story. This is a product that, once people find it, they keep using and keep telling others about.
That kind of growth doesn’t come from a single isolated marketing or promotional campaign. It comes from a product that does its job well enough that users become the marketing department.
#1: The Growth Loop
Most marketing is a funnel: you pour money in at the top, customers come out at the bottom, and when you stop spending, the growth stops. A growth loop is different. The output of getting one user becomes the input for getting the next, and the cycle feeds itself without constant reinvestment.
Granola’s core loop is elegant and almost accidental in how naturally it emerges from the product. When a meeting ends, you have polished, shareable notes. Sharing them is one click - it can be a URL you can copy, drop into Slack, email, or via a follow-up message. The recipient, who may never have heard of Granola, opens a beautifully formatted summary of the meeting they were just in. Some of them want that for their own calls.
Every note shared is a product demo. Every non-Granola user who receives one is a potential convert. The product grows every time it’s used.
The cultural signal of this is starting to show. People have started saying “just Granola it” and “Just Granola it” merch is also being sported. Using the product name as a verb suggests that the behavior has become so habitual that the product and the action have merged in people’s minds. That’s the kind of brand position that’s nearly impossible to buy.
#2: Community and Influencer Distribution
Alongside the organic loop, Granola has built deliberate distribution through communities where their target users already congregate.
Partnerships with communities like NextPlay and Lenny’s Newsletter makes sure Granola is surgically inserted into the professional networks of exactly the kind of people Granola is built for. Lenny Rachitsky’s audience skews heavily toward product managers, founders, and operators: people who live in back-to-back meetings and feel the pain Granola solves every single day. With these partnerships, Granola is reaching people who are one conversation away from becoming paying users.
The Recipes mechanic extends this further. Prolific users and creators (including contributors like Lenny) submit workflow templates that get shared with their communities. Each Recipe is both a product tutorial and a distribution event: someone shares a template, their audience tries it, and the loop starts again. It turns Granola’s most enthusiastic users into a distributed growth team.
#3: Product-Led Growth Meets Sales Infrastructure
For a long time, Granola’s growth was almost entirely inbound. The product spread, people signed up, and the team tried to keep up. Which sounds like a good problem until the inbound volume outgrows your ability to act on it.
At a certain scale, product-led growth needs a sales motion to convert it. Granola’s inbox was full of high-potential leads with no systematic way to prioritize them. Product usage data lived separately from customer records. Manual triage was consuming hours that should have been spent closing.
Their solution was to use Attio to build a proper GTM infrastructure: inbound leads captured automatically, product usage signals connected to customer records, and routing logic that surfaces the highest-value prospects for the sales team before they go cold. Fast-growing PLG companies eventually need to build the infrastructure to harvest what the product generates. Waiting too long means leaving significant revenue on the table.
#4: Growth via Retention
Underlying all of this is a bet that most companies talk about but few actually optimize for: that retention is a more powerful growth driver than acquisition.
Granola’s 70% weekly retention means the leads that come in are genuinely valuable.
A product that keeps 70% of its users active every week grows differently than one that acquires aggressively and churns just as fast. Each retained user is a potential evangelist, a potential sharer, a potential enterprise license. The network of trust that builds around a product people genuinely rely on is the hardest thing for competitors to replicate and the most durable foundation for everything else.
Granola didn’t build growth loops, community partnerships, and sales infrastructure as separate initiatives. They’re all downstream of the same bet: if you build something people actually need, the growth takes care of more than you’d expect. The job is to make sure you’re ready for it when it arrives.
Building the jetpack for the mind
Andrej Karpathy has a useful framework for thinking about AI tools: a variable autonomy slider. At the low end, the human operates and the AI responds to commands. At the high end, the human just approves - the AI runs independently across long stretches.
Karpathy’s insight, drawn from years working on full self-driving at Tesla, is that full autonomy is a decade-long roadmap. The real value right now lives in the middle: AI capable enough to handle the hard work, but on enough of a leash that humans stay engaged with the output.
The smartest AI products being built today are all staking their claim somewhere in that middle zone. The question is how you get in.
Granola’s answer was to ask a different question. The AI transcription market was already crowded when they launched - Otter, Fireflies, Fathom, all racing to answer the same question: how do we transcribe better?
Granola stepped off that treadmill entirely and asked something else: what do people actually want from their meeting notes? The answer turned out to be notes that sound like them, organized the way they think, that they trust enough to share and act on.
By starting with the human’s notes rather than the AI’s transcript, they wedged themselves into the middle of that autonomy slider and made it their own - not a transcription tool, not a fully automated assistant, but something that sits in the productive tension between the two.
The result is a product that captures 80–85% of what happens in a meeting. That baseline is superhuman in its consistency - no human takes notes that good, that reliably, across every single call. But Granola stops short of doing everything.
What actually matters, what gets sent, how the follow-up gets framed - that stays with the user. What Granola targets is the busywork: low-judgment, high-frequency processing that drains time without requiring anything uniquely human. What it preserves is everything related to voice, judgment, relationship and persuasion.
The result is that the output still feels like it belongs to you. This matters more than it might seem. When AI takes over entirely, people disengage as the notes could have been anyone’s, the follow-up reads like a template, the whole thing loses the texture that makes professional communication land. Granola’s bet is that knowledge workers will always want tools that make them ten times better at their craft, not tools that do the craft for them.
But staying in the middle zone is a starting position, not a destination. Every product has to evolve, and Granola is no different.
The next phase of Granola is about making everything captured actually work for you across time, across teams, and across the tools where work actually happens. That’s a horizontal game, and it’s a much bigger one.
Here’s what makes it defensible. A single user’s meeting notes are useful. A whole team’s meeting notes, accumulated over a year, structured and searchable - that becomes a different category of asset entirely.
Think about what a year’s worth of customer calls actually contains: every objection raised, every feature requested, every commitment made, every signal about what’s working and what isn’t. Right now, that intelligence lives in scattered notes, fading memories, and CRM fields nobody keeps updated.
Granola’s long-term play is to make that intelligence live - surfacing automatically when it’s relevant. You’re about to get on a call with a customer you haven’t spoken to in three months.
Granola already knows what was discussed last time, what was promised, what went unresolved. You walk in prepared without doing anything. The more a team uses Granola, the more context it accumulates, and the more valuable that context becomes for every future interaction. That’s the real moat - not the AI model underneath, which anyone can access, but the irreplaceable institutional memory built on top of it.
This is also precisely where the competitive picture gets interesting. Notion and ClickUp pose a real threat - not because they’ll build something better than Granola, but because they’ll build something good enough, wrapped inside a tool people are already habituated to. For a horizontal platform, meeting intelligence is one feature among dozens. It gets built, shipped, and deprioritized. The roadmap always has something else on it.
Granola’s edge is that meeting intelligence is the entire product. Every design decision, every integration, every workflow optimization is in service of one problem. The CRM integrations with tools like Attio and HubSpot aren’t features - they’re the execution of a thesis: that the most valuable thing Granola can do is close the gap between what gets said in meetings and what gets done in the systems where work actually lives. Whoever builds that bridge most cleanly wins a significant share of the knowledge worker’s day.
A horizontal tool will always treat that bridge as a nice-to-have. For Granola, it’s the whole game.
The Wrapper That Wasn’t
Which brings us back to where this essay started.
Granola began as something that looked, from the outside, like exactly the kind of AI wrapper that gets dismissed at dinner parties. A thin layer on top of a transcription API. A notes app with a prompt attached that said “Dude, it’s just a wrapper.”
What it actually was, and what the best wrapper companies always are, is a specific answer to a specific question that nobody else was asking carefully enough. Not “how do we transcribe meetings?” but “what do people actually need to happen after a meeting, and how do we make all of it effortless?”
Three years in, the answer has compounded into a product with genuine defensibility: a human-centered interaction model that people trust, a repository that gets more valuable the longer you use it, a distribution strategy that turned VCs into evangelists, and an agentic layer that’s only beginning to show what it can do.
The steering wheel hasn’t been invented yet. But Granola is one of the teams closest to figuring out what it should look like.
If this essay made you think differently, share it with someone who’s building. And if you want your company’s story told with this kind of depth, book a call and let’s chat.