Why We Chose SvelteKit to Build Grafite

The Framework Nobody Asks About (Until They Feel the Difference)

Nobody signs up for a productivity tool because of the framework it's built on. You sign up because it solves a problem. But the framework underneath absolutely shapes the experience you get. How fast the app loads. How smooth the interactions feel. Whether the whole thing works on your phone just as well as it does on your laptop. Whether it feels like a real app or a glorified web page.

We built Grafite on SvelteKit. Not React, not Next.js, not Angular, not Vue. And while we're not going to walk you through our entire codebase, we do think the reasoning behind that choice is worth sharing, because it's deeply connected to the product philosophy that drives everything we build.

What Is Svelte, and Why Is It Different?

If you're not a developer, here's the short version: most modern web apps are built on JavaScript frameworks. React (made by Meta) is the most popular one by far. Vue and Angular are the other big names. These frameworks all work roughly the same way, they ship a runtime to the browser, and that runtime handles updating the page when things change.

Svelte takes a fundamentally different approach. Instead of shipping a runtime, Svelte compiles your code at build time into lean, optimized JavaScript. The framework essentially disappears. What arrives in the browser is just the code your app actually needs, no extra abstraction layer sitting between the user and the interface.

SvelteKit is the full-stack framework built on top of Svelte. Think of Svelte as the engine and SvelteKit as the complete vehicle. It handles routing, server-side rendering, API endpoints, data loading, and deployment. It's the whole package.

Why Not React?

React is a great tool. It has the largest ecosystem, the most third-party libraries, and the biggest hiring pool. If you're building a massive team at a big company and you want the safest possible bet for recruitment, React is a reasonable choice.

But we're not optimizing for the safest hiring bet. We're optimizing for the best user experience.

React ships more JavaScript to the browser. Every component carries the overhead of React's virtual DOM, an abstraction layer that figures out what changed and updates the page accordingly. It's clever engineering. It's also weight your browser has to carry on every page load, on every interaction, on every device.

For a tool like Grafite, where you might be opening the app on your phone between meetings, or pulling it up on a tablet during a conference, or using it on a work laptop with twenty other tabs open, that weight matters. Every kilobyte of JavaScript is time spent parsing and executing code before you can actually use the app.

Svelte doesn't have a virtual DOM. It compiles reactive updates into surgical DOM operations at build time. The result: smaller bundles, faster load times, and interactions that feel immediate rather than "pretty fast."

It's the difference between a car that accelerates quickly and one that's already at speed.

Browser-First, Not Desktop-First

Here's where the framework choice and the product philosophy intersect.

We made a deliberate decision early on to build Grafite as a browser-based application. Not a desktop app. Not a mobile app you download from an app store. Not an Electron wrapper pretending to be native. A real web app that runs in any modern browser on any device.

That decision was philosophical as much as it was technical. We wanted Grafite to be something you could access from anywhere, your work laptop, your personal phone, a tablet, a borrowed computer. No installation, no setup headaches, no updates to manage. Open a tab and you're in.

But going browser-first means you're asking the browser to do a lot. Recording audio, processing transcriptions, rendering rich text editors, managing real-time state across multiple features, all of that runs in the browser. And if your framework is shipping hundreds of kilobytes of overhead before your actual application code even loads, the experience suffers. Especially on mobile. Especially on slower connections.

SvelteKit lets us build a genuinely capable application that still feels lightweight. The compiled output is lean. Pages load fast. Navigating between your notes, your tasks, your people directory, your calendar, it all happens without the sluggishness you sometimes feel in heavier web apps.

That matters when your tool is supposed to be open all day, every day, alongside everything else you're running.

What You Actually Feel

The technical stuff is interesting (to us, at least), but what matters is how it translates to your experience. Here's what SvelteKit enables in Grafite that you probably don't think about but definitely feel:

Instant navigation. Moving between features, notes, tasks, people, calendar, Ask Grafi, happens without full page reloads. SvelteKit's client-side routing means transitions are smooth and immediate. It feels like a native app, not a series of web pages loading one after another.

Fast first load. When you open Grafite in a new tab, the app is ready quickly. There's no long spinner while a massive JavaScript bundle downloads and parses. Svelte's compiled output means less code to deliver and less code for your browser to process.

Responsive across devices. The same app works on your desktop, your tablet, and your phone, and it feels right on all of them. We're not maintaining separate codebases for different platforms. SvelteKit's server-side rendering combined with Svelte's efficient client-side hydration means the app performs well even on less powerful devices.

Recording without lag. When you're recording a meeting, the last thing you want is a sluggish interface. Audio capture, real-time status updates, silence detection, timer displays, all of that runs smoothly because the framework isn't eating up CPU cycles on its own overhead.

Progressive web app. Grafite installs to your home screen on mobile and behaves like a standalone app, no app store required. SvelteKit's architecture makes PWA support straightforward, which reinforces our whole "works everywhere, installs nowhere" philosophy.

The Developer Experience Shapes the Product

There's a less obvious benefit worth mentioning: SvelteKit makes us faster at building features.

Svelte's syntax is remarkably close to standard HTML, CSS, and JavaScript. There's less boilerplate, less ceremony, fewer abstractions to work around. When we want to build a new feature, say, folder organization, or voice input for Ask Grafi, or meeting prep cards, we can move quickly because the framework isn't fighting us.

That velocity matters for a small team. We're not a company with hundreds of engineers. Every hour we don't spend wrestling with framework complexity is an hour we spend building something you'll actually use. SvelteKit gives us an edge that translates directly into faster feature delivery.

The Tradeoffs (Because Nothing Is Perfect)

We'd be dishonest if we didn't mention the other side. Svelte's ecosystem is smaller than React's. There are fewer third-party component libraries, fewer Stack Overflow answers, fewer blog posts about solving obscure problems. When we hit an edge case, sometimes the answer isn't a quick search away.

The talent pool is smaller, too. If we were hiring dozens of frontend engineers, the React candidate pool would be dramatically larger. For a focused team that values quality over scale, this hasn't been a real constraint, but it's a real consideration.

And because Svelte compiles away the framework, some debugging patterns are different from what developers might be used to in React. The learning curve isn't steep, but it exists.

For us, these tradeoffs are well worth it. The performance gains, the developer experience, and the alignment with our browser-first philosophy outweigh the smaller ecosystem. We'd rather build on the foundation that produces the best product than the one that produces the most Google results.

The Right Tool for What We're Building

Choosing a framework isn't just a technical decision. It's a product decision. We chose SvelteKit because it aligns with what Grafite is supposed to be: fast, lightweight, browser-native, and available everywhere without friction.

If you've ever used Grafite and thought "this feels fast" or "this works surprisingly well on my phone", that's not an accident. It's what happens when the framework gets out of the way and lets the product breathe.

We're not here to start a framework war. React is excellent for a lot of things. So is Vue. Use what works for your project. For ours, a browser-first productivity tool that needs to feel instant on every device, SvelteKit was the right call. And every day we ship features to grafite.io, we're more confident in that choice.

---

Grafite is a browser-based meeting intelligence platform. AI transcription, summaries, tasks, people tracking, and conversational AI search, all in a single tab. No installs, no bots, no app stores. Try it free.