Get AI summaries of any video or article — Sign up free
My Bleeding Edge Tech Stack for 2025 thumbnail

My Bleeding Edge Tech Stack for 2025

Fireship·
5 min read

Based on Fireship's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

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?

SvelteKit is selected for its combination of server-side rendering (to make pages visible to search engines and bots) and client-side routing after the initial load. That routing behavior matters when the app becomes more interactive—especially when authentication is involved—because it reduces full page reloads and keeps user flows smooth. Astro is praised for content-driven sites, but it’s positioned as a better match for a portfolio rebuild. Next.js is treated as a strong runner-up, with features like nested routing, but SvelteKit’s routing model and Svelte’s developer experience are the deciding factors.

What makes Svelte’s reactivity and state sharing feel “productive” compared with other UI libraries?

Svelte’s reactive model is described as natural: when a mutable variable changes, the UI updates directly without forcing developers through extra steps to wire reactivity. For cross-component data sharing, Svelte stores are used; they behave like observable subjects (similar in spirit to RxJS subjects) and can be accessed anywhere in the app by referencing the store with a dollar sign. The approach is compared to Angular’s patterns but with less boilerplate.

What is the biggest risk in choosing SvelteKit at the time of planning?

The risk is framework stability. Using a meta framework that isn’t at a stable release means late changes could disrupt an application built on top of it—potentially breaking core features or requiring significant rework. The plan treats this as an acceptable risk because the project’s needs justify SvelteKit’s capabilities, and the likelihood of a catastrophic change is considered low.

How does the stack avoid heavy server-side rendering complexity?

Instead of relying on a full-stack SSR framework tied to a particular backend (like Rails, Laravel, or Django), the plan leans on pre-rendering. Content changes infrequently, so the site can be rendered ahead of time, uploaded to storage, and cached via a CDN worldwide. This shifts the workload from dynamic SSR to static generation plus caching, simplifying operations.

Why keep Firebase despite concerns about lock-in?

Firebase is kept because it covers most backend needs—described as roughly 90%—with managed services that speed up development. Firestore as a document database is considered sufficient for many apps, similar to MongoDB in spirit. The trade-offs are lock-in to Google Cloud Platform and potential edge-case gaps, such as advanced authentication features or complex database queries that Firebase may not support well.

Which external services fill gaps that the core stack doesn’t handle directly?

Transactional email is handled via SendGrid. Full-text search for content is delegated to Algolia, with a note that costs can rise on very large sites but is manageable for the project’s scale. Payments are handled with Stripe and PayPal. For testing, Cypress is the default all-in-one approach, with Playwright as an alternative for end-to-end tests and V-test as a unit-testing option tied to the Vite/vee ecosystem.

Review Questions

  1. If SvelteKit were unavailable or too unstable, which alternative would best match the need for SSR plus client-side routing, and why?
  2. What specific limitations of Firebase (as described) would push a team toward a traditional SQL database or a different backend architecture?
  3. How do pre-rendering and CDN caching change the operational trade-offs compared with dynamic server-side rendering?

Key Points

  1. 1

    SvelteKit is chosen for SSR plus client-side routing, which supports interactive, authenticated course experiences.

  2. 2

    Svelte’s reactivity is valued for direct UI updates when state changes, and stores provide low-boilerplate cross-component data sharing.

  3. 3

    The plan accepts beta-framework risk with SvelteKit because its routing and developer experience align with the project’s needs.

  4. 4

    Pre-rendering plus CDN caching replaces heavy full-stack SSR frameworks when site content changes infrequently.

  5. 5

    Tailwind is used to speed up CSS work and keep initial page loads fast via automatic style purging.

  6. 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. 7

    Cypress, SendGrid, Algolia, and Stripe/PayPal round out testing, email, search, and payments to keep the core stack lean.

Highlights

SvelteKit is picked not just for SSR, but for client-side routing after the first load—critical for interactive, authenticated flows.
Firebase is treated as “good enough” for most apps (about 90%) via Firestore, with the main concern being Google Cloud lock-in and advanced auth/query limitations.
The rendering strategy avoids complex SSR frameworks by pre-rendering the site and caching it globally through a CDN.
Tailwind is positioned as the practical fix for spending more time on CSS than on JavaScript, while still preserving design control.

Topics

Mentioned

  • SSR
  • CDN
  • SQL
  • ORM
  • RxJS