My Bleeding Edge Tech Stack for 2025
Based on Fireship's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.
SvelteKit is chosen for SSR plus client-side routing, which supports interactive, authenticated course experiences.
Briefing
The core plan for a 2025-ready app stack centers on pairing SvelteKit for the front end with Firebase for the back end—an intentionally pragmatic mix aimed at shipping fast while still supporting interactive, content-heavy features like course progress, quizzes, and demos. The choice matters because modern web development bottlenecks less on “what can be built” and more on how quickly teams can iterate without getting trapped in excessive complexity or brittle infrastructure decisions.
On the UI side, Svelte is the default pick because reactive updates feel direct: when mutable state changes, the interface updates without forcing developers through extra ceremony. Data sharing across components happens through Svelte stores, a pattern likened to RxJS “subjects” but with a simpler mental model—observable anywhere in the app by referencing the store. While the current Fireship build uses Angular, the stack decision is framed as a productivity trade: Angular’s enterprise strength is acknowledged, React’s ecosystem remains a major reason to choose it, and alternatives like SolidJS and Vue are considered for performance and library support. The bigger decision, though, is the meta framework.
For server-side rendering and routing, SvelteKit is treated as the best fit despite being in beta at the time of planning. The risk is explicit: building on an unstable framework can backfire if a late-breaking change lands before a production release. Still, the project’s needs—especially client-side routing after initial load for interactive experiences and authentication—push the preference toward SvelteKit over other SSR approaches. Astro is flagged as a strong option for content-driven sites, but it’s positioned as better suited to a portfolio rebuild, not the course platform. Next.js is named as the runner-up, with features like nested routing and continued momentum, while “Quick” is mentioned as a more radical rendering approach using resumable/replayable applications—too bleeding edge for this particular plan.
On the rendering strategy, the stack avoids heavy full-stack SSR frameworks (Rails, Laravel, Django) because the site content doesn’t change frequently. Instead, it leans toward pre-rendering the site, uploading static output to storage, and caching globally via a CDN—reducing operational overhead. Scaling then becomes a choice between serverless functions for elasticity or Kubernetes for more complex setups.
For tooling, TypeScript is the default for larger projects, while Tailwind is the CSS strategy to reduce time lost to styling details and speed up prototyping. Tailwind’s utility-first workflow is valued for control and iteration speed, and its purge mechanism helps keep CSS bundles lean for faster initial loads. DaisyUI is suggested as a shortcut if utility classes are the preferred direction, though the plan is to build custom styling.
Back end decisions keep Firebase as the centerpiece because it covers roughly 90% of what most apps need: Firestore as a document database, plus managed services that accelerate development. The main drawback is lock-in to Google Cloud Platform and limitations around advanced authentication and complex queries. For testing, Cypress is favored for end-to-end and unit coverage in one package, with Playwright as an alternative and V-test as a unit-testing option tied to the Vite ecosystem. External services fill gaps: SendGrid for transactional email, Algolia for full-text search, and Stripe plus PayPal for payments. The resulting stack is intentionally simple—SvelteKit plus Firebase—despite the lack of a clean acronym.
Cornell Notes
The 2025 stack plan pairs SvelteKit (front end) with Firebase (back end) to balance speed, interactivity, and manageable complexity. Svelte is favored for natural reactivity and straightforward state sharing via stores, while SvelteKit is chosen for SSR plus client-side routing needed for authenticated, interactive course experiences. The plan accepts some risk by using SvelteKit while it’s still in beta, because the project’s needs align better than alternatives like Astro or Next.js. Firebase remains the back-end default because it handles most app requirements through Firestore and managed services, with the main trade-off being Google Cloud lock-in and limitations for advanced auth or complex queries. Testing and missing capabilities are handled with Cypress, SendGrid, Algolia, and Stripe/PayPal.
Why does SvelteKit fit better than other SSR/meta-framework options for an interactive course platform?
What makes Svelte’s reactivity and state sharing feel “productive” compared with other UI libraries?
What is the biggest risk in choosing SvelteKit at the time of planning?
How does the stack avoid heavy server-side rendering complexity?
Why keep Firebase despite concerns about lock-in?
Which external services fill gaps that the core stack doesn’t handle directly?
Review Questions
- If SvelteKit were unavailable or too unstable, which alternative would best match the need for SSR plus client-side routing, and why?
- What specific limitations of Firebase (as described) would push a team toward a traditional SQL database or a different backend architecture?
- How do pre-rendering and CDN caching change the operational trade-offs compared with dynamic server-side rendering?
Key Points
- 1
SvelteKit is chosen for SSR plus client-side routing, which supports interactive, authenticated course experiences.
- 2
Svelte’s reactivity is valued for direct UI updates when state changes, and stores provide low-boilerplate cross-component data sharing.
- 3
The plan accepts beta-framework risk with SvelteKit because its routing and developer experience align with the project’s needs.
- 4
Pre-rendering plus CDN caching replaces heavy full-stack SSR frameworks when site content changes infrequently.
- 5
Tailwind is used to speed up CSS work and keep initial page loads fast via automatic style purging.
- 6
Firebase remains the backend default for managed services and Firestore’s document model, with lock-in and query/auth edge cases as the main downsides.
- 7
Cypress, SendGrid, Algolia, and Stripe/PayPal round out testing, email, search, and payments to keep the core stack lean.