Why I Switched to SvelteKit
A practical guide to migrating from Next.js to SvelteKit, and why it might be the right move for your next project.
Choosing a tech stack feels easy at first. You pick what’s popular, what everyone recommends, and what trends suggest is “the best.” But real understanding only comes after building, breaking, migrating, and rebuilding again.
This is the story of how my portfolio evolved across multiple frameworks—and what each migration taught me.
Phase 1 — Starting with Next.js (The Obvious Choice)
When I began building my portfolio, I chose Next.js with React. The decision felt obvious because everything pointed toward it.
- GPT strongly recommended it as the best modern stack
- Developers widely trusted it
- It had built-in routing, SSR, static generation, and optimization
- It provided excellent SEO capabilities
- It dominated industry trend reports like:
It seemed like the safest and smartest decision.
When both AI and industry trends agree, it feels impossible to go wrong.
And initially, it worked perfectly.
Realization — The Hidden Tradeoff
As I gained more experience, I started noticing something important.
- Many advanced features were optimized specifically for Vercel
- Some functionality required extra setup outside the Vercel ecosystem
- Platform independence became an important factor
Next.js was powerful—but it made me realize something deeper:
Convenience and flexibility are not always the same thing.
That realization pushed me to explore other rising frameworks.
Phase 2 — Experimenting with TanStack Start
I was already using:
- TanStack Query
- TanStack Router
Their design philosophy impressed me. They were:
- Simple
- Explicit
- Flexible
- Developer-focused
So I migrated my portfolio to TanStack Start.
Using Context7 files, I provided structured context to AI and migrated most of the project successfully.
But deployment became a major challenge:
- Complex setup and configuration
- Deployment instability
- Ecosystem still evolving
- Time spent fixing infrastructure instead of building features
Promising frameworks are exciting—but ecosystem maturity matters.
I had invested too much progress to risk losing it.
Phase 3 — Moving to Astro (Performance-Focused)
Astro looked extremely promising, especially for performance and content.
What worked well:
- Clean and structured architecture
- Excellent content rendering
- Minimal JavaScript by default
- Great developer experience
But my portfolio wasn’t just content—it was animation-heavy.
Problems I encountered:
- Animations didn’t feel smooth
- Interactions felt slower than expected
- Required extra setup for dynamic behavior
Astro excels at content—but my portfolio needed interaction.
Astro was great—but not the right fit for my specific use case.
Phase 4 — Discovering SvelteKit (The Turning Point)
That’s when I discovered SvelteKit.
Immediately, several things stood out:
- Clean and intuitive file-based routing
- Minimal boilerplate
- Excellent performance
- Simple and readable architecture
- Strong flexibility and independence
I migrated my portfolio again.
The only challenge was animations.
- Svelte uses its own animation system
- Framer Motion wasn’t directly compatible
- I had to rebuild animations using Svelte motion libraries
It required effort—but the results were worth it.
Once rebuilt, everything became faster, cleaner, and easier to maintain.
Framework Comparison Summary
| Framework | Strength | Challenge | Key Lesson |
|---|---|---|---|
| Next.js | Powerful, popular, SEO friendly | Platform optimization dependency | Popularity ≠ perfect fit |
| TanStack Start | Flexible, modern architecture | Ecosystem maturity, deployment issues | Maturity matters |
| Astro | Excellent for static content | Not ideal for heavy interaction | Use tools for the right purpose |
| SvelteKit | Fast, clean, flexible, stable | Rebuilding animations required effort | Simplicity improves long-term productivity |
Why I Chose SvelteKit
SvelteKit gave me something that other frameworks didn’t fully provide:
- Clean architecture
- Excellent performance
- Platform independence
- Minimal maintenance overhead
- Long-term stability
It allowed me to focus on building—not maintaining the framework.
What This Journey Taught Me
This journey was frustrating at times.
Migrating multiple times meant:
- Rewriting code
- Fixing deployment issues
- Rebuilding animations
- Learning new architectures
But it also taught me lessons that no tutorial could:
- No framework is perfect
- Every tool has tradeoffs
- Trends should guide—not decide—your choices
- Real learning comes from experience
The migrations weren’t setbacks. They were the learning process.
Final Reflection
Looking back, each framework taught me something valuable:
- Next.js taught me modern architecture
- TanStack taught me flexibility
- Astro taught me performance design
- SvelteKit taught me simplicity and control
Frameworks evolve. Trends change.
But the experience gained from building, migrating, and understanding systems—that stays forever.
In the end, the best framework isn’t the most popular one. It’s the one that lets you build with confidence.