TechPrufer
Get started
Vercel
Vercel logoVercel · Feature trail

Turborepo Performance Optimizations

41 posts · Dec 2021 – Mar 2026

What this trail covers

Turborepo continues to evolve its performance optimizations, with recent efforts focusing on reducing the overhead of task graph computation. This includes leveraging AI agents for initial performance analysis and code suggestions, developing LLM-friendly profiling formats (Markdown-based profiles), and integrating these insights with human engineering practices. The goal is to make Turborepo's task graph computation near-instantaneous, even for very large monorepos, by optimizing hashing algorithms, reducing allocations, and improving the efficiency of internal algorithms. The integration of sandboxes and rigorous testing ensures these performance gains are realized in real-world scenarios.

All Vercel trails
  1. Making Turborepo 96% faster with agents, sandboxes, and humansThis post details significant performance improvements in Turborepo's task graph computation, achieving up to 96% speedup. Key contributions include: 1. Initial performance gains from unattended AI agents, identifying optimizations in hashing (replacing twox-hash with xxhash-rust) and algorithmic improvements (replacing Floyd-Warshall with DFS). 2. Development of a new `turborepo-profile-md` crate to generate LLM-friendly Markdown profiles from Chrome Tracing JSON, enabling agents and humans to more easily parse and analyze performance data. 3. Integration of Vercel Sandboxes for testing and verification. 4. Refinements to hashing algorithms (hashing by reference instead of cloning HashMaps) and algorithmic replacements to reduce allocation pressure and improve execution speed. The post emphasizes the iterative process of combining AI assistance with traditional engineering practices, including profiling and benchmarking, to achieve these gains.
  2. How Vercel adopted microfrontendsThis post details Vercel's adoption of vertical microfrontends for its main website and dashboard. It explains the rationale behind the shift from a monolithic Next.js application to address growing build times and dependency complexity. The post outlines the choice between horizontal and vertical microfrontend splits, detailing Vercel's decision to adopt vertical microfrontends for their specific use case. It describes the migration path, breaking down the application into marketing, documentation, and the logged-in dashboard, and leveraging Next.js Multi-Zones. The use of Turborepo, Dependency Cruiser, and feature flags for incremental migration and traffic routing is highlighted. The benefits include improved developer experience, reduced build times, and enhanced end-user performance.
  3. Turbopack updates: Moving homesThis post announces the migration of the Turbopack codebase from the `vercel/turbo` repository into the `vercel/next.js` monorepo. This move is intended to improve iteration speed and facilitate faster development of production builds by co-locating Turbopack with its primary user, Next.js. The post details current project updates, including Turbopack's compatibility with Next.js, and outlines future priorities such as bug fixing, memory reduction, completing the on-disk cache, and achieving full production build support. The migration will be performed using `git-subtree` and `git-filter-branch`.
  4. Finishing Turborepo's migration from Go to RustThis post details the completion of Turborepo's migration from Go to Rust. It covers the porting of key components such as file hashing, lockfile analysis, the `run` command (including package graph construction), and the `prune` command. The article highlights the use of Rust enums for better type safety in package naming, the strategy of using Capnproto for cross-language hash stability, and the dogfooding process involving experimental flags and internal CI testing. The migration aims to unlock future performance gains and new features.
  5. How to scale a large codebaseThis post details Vercel's recommendations for scaling large codebases, advocating for a monorepo architecture facilitated by Turborepo. It highlights Turborepo's caching mechanisms for near-instant builds and efficient task orchestration. The post also emphasizes the importance of feature flags for confident releases, recommending Vercel Edge Config for low-latency flag storage, and discusses incremental builds with Turborepo to de-risk experimentation by only rebuilding changed code.
  7. Building the most ambitious sites on the Web with Vercel and Next.js 14This post announces the stable release of Server Actions in Next.js 14, experimental Partial Prerendering, and significant performance improvements in Next.js startup and code updates (22% and 29% respectively). It also highlights Turbopack's performance gains (53.3% faster startup, 94.7% faster code updates) and the ongoing migration of the Next.js CLI and bundler to Rust. The post emphasizes the adoption of the App Router and Server Components by major companies and showcases how these features improve performance and developer experience.
  8. Using Zig in our incremental Turborepo migration from Go to RustThis post details the incremental migration strategy for porting Turborepo's `run` and `prune` commands from Go to Rust. It introduces the 'Rust-Go-Rust sandwich' approach, where a Rust binary calls a Go binary which in turn calls statically linked Rust libraries. This method utilizes CGO for linking Rust static libraries into Go and protobuf for inter-language communication. The post also describes the process of porting specific functions like `getGlobalHashableEnvVars` by splitting code into Go and Rust implementations and using Go build tags for toggling.
  9. Engineering a site at the speed of breaking news | Customers | VercelThis post details The Washington Post's migration to Next.js and Vercel for their election engineering platform. Key technical aspects include: replacing an AWS ECS-based rendering layer with Vercel, migrating to Next.js 12 to utilize Incremental Static Regeneration (ISR), hosting both development and production environments on Vercel, rewriting the frontend in TypeScript, and improving test coverage. The post highlights Vercel's ability to handle spiky traffic and streaming data, enabling scalability and responsiveness. A specific technical challenge addressed was a lagging WebSocket solution for a high-data-load page, which was rewritten successfully. The migration aimed to reduce complexity, improve developer onboarding, and lower costs compared to their previous AWS infrastructure.
  10. How Vercel helped this popular health database increase free trials by 284% | Customers | VercelThis post details how Examine.com migrated to Vercel's Frontend Cloud, resulting in a 90% reduction in build times (from 15-20 minutes to 1-2 minutes) and a 284% increase in free trial signups. Key technical improvements include decoupling frontend and backend, leveraging Next.js for dynamic loading and prefetching, and utilizing Incremental Static Regeneration (ISR), Server-Side Rendering (SSR), and Preview Deployments for faster iteration and improved developer workflow.
  11. How Turborepo is porting from Go to RustThis post details the 'how' of Turborepo's migration from Go to Rust, focusing on an incremental porting strategy over a full rewrite. It explains the implementation of the global `turbo` feature using a Rust shim and CGO, and the porting of CLI argument parsing using the `clap` crate and JSON serialization for interop. It also highlights challenges encountered on Windows, specifically with MSVC vs. MinGW toolchains and UNC paths, and the resolution of moving the Rust toolchain to MinGW.
  12. Incrementally adopting Next.js at one of Europe's fastest growing brands | Customers | VercelThis post details reMarkable's incremental migration from Gatsby to Next.js and Vercel, focusing on the technical aspects of improving developer experience and performance. Key technical contributions include: achieving an 87% reduction in production build times (from 5m 55s to 39s) by adopting Next.js; improving development build startup times; leveraging Vercel Preview Deployments for faster stakeholder review cycles and feedback collection; and enabling a self-sufficient editorial team by integrating Sanity for custom landing page creation without developer intervention. The migration strategy involved modifying the website structure, moving to a pages folder, lifting data fetching to the pages-level, and rewriting queries before swapping frameworks.
  13. How Neo Financial cut time spent on infrastructure admin by 50% | Customers | VercelThis post details how Neo Financial migrated from a self-managed AWS Fargate infrastructure to Vercel's Frontend Cloud. Key technical achievements include a 77% improvement in page load speed through Next.js server rendering, the use of Edge Middleware for real-time translations, and a 50% reduction in infrastructure administrative effort. The migration also highlights the benefits of Vercel's Preview Deployments for faster release cycles and collaboration, and the platform's inherent scalability and security for a financial services application.
  14. Containing multi-site management within a single codebase | Customers | VercelThis post details how Wunderman Thompson uses a monorepo workflow with Turborepo, combined with Atomic Design principles and a headless CMS, to manage multiple client websites from a single codebase on Vercel's serverless platform. It highlights the benefits of component-based frameworks like Next.js and SvelteKit for efficient development, streamlined data management, and infrastructure automation.
  15. Why Turborepo is migrating from Go to RustThis post details the technical motivations and benefits of migrating Turborepo from Go to Rust. It contrasts Go's simplicity and runtime error handling with Rust's emphasis on compile-time correctness and expressiveness, particularly in areas like filesystem operations and interfacing with native libraries (e.g., zstd, libgit2 via git2 crate). The migration aims to improve performance, stability, and developer experience, aligning the Turborepo and Turbopack teams' tooling.
  16. Optimizing performance for over 6M monthly visitors at CruiseCritic | Customers | VercelThis post details Cruise Critic's migration from a monolithic PHP application to Next.js and Vercel. Key technical outcomes include a reduction in engineering build times from 30 minutes to under eight minutes, enabling multiple deployments per day. Page performance saw an 85% decrease in download time and a nearly 100% decrease in page size.
  17. Moving from monolithic WordPress to composable gives Plenti total freedom | Customers | VercelThis post details Plenti's successful migration from a monolithic WordPress stack to a composable Next.js frontend on Vercel, managed by a single engineer. It highlights the flexibility and speed of Next.js, the utility of the Vercel API for triggering deployments via a Strapi plugin, and the value of Vercel Analytics (specifically Real Experience Score) for optimizing user experience.
  18. How Makeswift improved CI speed by 65% with Turborepo | Customers | VercelThis post details how Makeswift, a customer of Turborepo, achieved a 65% improvement in their CI pipeline time by adopting Turborepo. They transitioned from a custom build process involving Kubernetes and Bazel to Turborepo, which simplified their task scheduling for linting, typechecking, building, codegen, and more. This resulted in a significant reduction in commit-to-deploy time from 20 minutes to under one minute and improved their local development experience by allowing them to spin up their entire stack with a single command.
  19. How Vercel and Next.js keep Rippling on their rising path to success | Customers | VercelThis post details how Rippling, an HR platform, successfully scaled its frontend by adopting Next.js and Vercel. It highlights the benefits of Incremental Static Regeneration (ISR) for rapid content updates (sub-300ms propagation) and maintaining fast build times as the application grows. The post emphasizes how this stack empowers stakeholders to deploy over 90% of site changes immediately, freeing up engineering resources for performance improvements.
  20. How Indent delivers secure access with Next.js and Vercel | Customers | VercelThis post highlights how Indent uses Next.js and Vercel for a fast end-user experience and improved developer workflow. Key contributions include: 1. Leveraging Preview Deployments for faster feedback loops (80% improvement), enabling real-time sharing and commenting on work-in-progress. 2. Benefiting from Next.js's zero-migration features (Webpack 5, SWC compiler, built-in TypeScript and linting) for quality-of-life improvements and easier security patching. 3. Utilizing Vercel's platform with modern CMS like Sanity for non-technical team members to contribute content without code changes, with Preview Deployments ensuring fast feedback on content updates.
  21. Less code, better UX: Fetching data faster with the Next.js 13 App RouterThis post details the data fetching improvements in Next.js 13's App Router, focusing on React Server Components. It explains how data can be fetched directly within components, reducing boilerplate compared to the `pages` directory's `getServerSideProps` and `getStaticProps`. It highlights the benefits of Server Components for fetching data on the server, improving security and reducing client-server roundtrips. The post also explains how `fetch()` is now static by default, with options for revalidation and `no-store` for dynamic data, leveraging the Web API and async/await.
  22. Runway enables next-generation content creation with AI and Vercel | Customers | VercelThis post details Runway's migration to Vercel, highlighting a significant reduction in build times from 5-8 minutes to 40 seconds. It also mentions the use of Vercel Preview Deployments for improved feedback cycles and Vercel Analytics for performance monitoring.
  23. Moving from Gatsby to Next.jsThis post details a migration from Gatsby to Next.js for a large-scale React website, highlighting the benefits of Vercel's platform in facilitating this transition. Key technical contributions include: - Demonstrating Vercel's role in enabling safe migrations via preview deployments and instant rollbacks. - Showcasing how Vercel's infrastructure supports incremental adoption and headless CMS integration. - Quantifying performance improvements using Vercel Analytics and Checks, with a Real Experience Score improvement from 79 to 90. - Contrasting Next.js's full-stack capabilities and integrated solutions (e.g., `next/image`) with Gatsby's plugin-dependent approach for features like image optimization, reducing code lines and dependencies. - Explaining Next.js's simplified data fetching (`fetch` and `getStaticProps`) compared to Gatsby's multi-layered approach (plugins, `gatsby-config.js`, `gatsby-node.js`), emphasizing colocation and flexibility beyond GraphQL. - Detailing the significant reduction in build times (from 35 minutes to 5 minutes) by adopting a hybrid approach with Next.js's Incremental Static Regeneration (ISR) for a large number of static pages, balancing initial load times with CDN caching for subsequent users. - Reporting a successful migration in three weeks with zero downtime and an 85% reduction in build times.
  24. Iterate faster with Turborepo and Vercel Remote CacheThis post introduces the integration of Vercel Remote Cache with Turborepo, enabling multiplayer caching for build tasks. It details how to set up the Vercel Remote Cache with Turborepo CLI commands (`turbo login`, `turbo link`) and demonstrates its use in Vercel deployments. The post highlights the time savings achieved through cache hits and provides instructions for visualizing these savings in the Vercel Usage dashboard.
  25. Supabase improves their DX with Turborepo | Customers | VercelThis post details how Supabase improved their developer experience and deployment speed by adopting Turborepo. It highlights how Turborepo simplified their build process, allowing a single developer to make changes in one place and one pull request, drastically improving their developer experience and lowering the barrier to entry for contributions. The post also mentions Supabase's use of Vercel Preview Deployments with commenting for external team collaboration.
  26. How Vercel enables Wunderman Thompson to launch global brands | Customers | VercelThis post details how Wunderman Thompson leverages Turborepo's monorepo and remote caching for their UI kit, enabling fast development cycles and component sharing. It also highlights their use of Vercel's integrations ecosystem for headless CMS integration and Vercel Comments for fluid collaboration on live sites, transforming feedback processes from week-long back-and-forths to same-day deploys. The post also emphasizes the benefits of Vercel's globally serverless infrastructure and Vercel Checks for managing projects without server maintenance and catching site-breaking errors before launch.
  27. The Turbopack visionThis post details the vision behind Turbopack, explaining its motivation to move beyond the limitations of Webpack. It highlights the architectural approach of combining a 'Turbo engine' for core tasks like caching and incremental builds with Turbopack itself for bundling various assets. The post emphasizes the goal of achieving millisecond hot reloads and production builds in seconds through Turborepo-like Remote Caching. It also announces new alpha features in Next.js 13.1, including support for PostCSS, next/image, next/font, and next.config.js, and outlines future plans for supporting other frameworks and improving developer insights.
  28. How Remote Caching decreased publish times by 80%This post details the implementation of Turborepo Remote Caching within the Next.js CI pipeline to reduce publish times. It explains the previous challenges with caching SWC binaries, including repository bloat and cache miss rates. The solution leverages Turborepo's task management for per-platform binaries and its ability to avoid cache purges. Additionally, it describes an eager pre-seeding GitHub Action to build SWC binaries when code changes, ensuring cache hits for subsequent publishes.
  29. Building a viral application for your personal music festivalThis post details how Instafest, built with Next.js, scaled to 500,000 users per hour by leveraging Vercel's automatic scaling, global Edge Network for caching, and Vercel Functions, demonstrating robust performance and availability. It highlights the use of Next.js's built-in font optimization and image component for fast loading and responsive images, and Vercel's ability to handle massive traffic surges with zero downtime or increased latency.
  30. Migrate a large, open-source React application to Next.js and VercelThis post details the incremental migration of a large, open-source React application (BBC website) to Next.js and Vercel. Key technical contributions include: setting up Next.js with Emotion, configuring Webpack for import aliases and timezone data handling, adapting to Next.js's routing and data fetching mechanisms (getInitialData), and leveraging Vercel's preview deployments. The migration resulted in significant code reduction and improved local development iteration speed.
  31. DatoCMS builds 60% faster with a streamlined workflow | Customers | VercelThis post details how DatoCMS, a headless CMS provider, achieved a 60% reduction in build times by migrating to Next.js on Vercel. They were able to leverage both Static Generation and Server-Side Rendering, which was previously a limitation. The migration also streamlined their workflow by consolidating build, preview, and deploy processes onto a single platform, leading to the creation of their Realtime Updates API.
  32. How Vercel helped justInCase Technologies cut their build time in half | Customers | VercelThis post details how justInCase Technologies migrated to Vercel, experiencing 50% faster builds and eliminating preview failures. This resulted in 72 hours of saved developer time per month, enabling them to manage more products, build a new blog, and achieve a 100 score on PageSpeed Insights. The integration of GitHub Actions on Vercel further automated their workflow.
  33. With Next.js, Vercel, and Sanity, Loom empowers every team to iterate | Customers | VercelThis post details how Loom uses Next.js on Vercel with Sanity for a headless architecture, emphasizing fast iteration and collaboration. Key technical aspects include the use of preview deployments for content creators and stakeholders to test changes without engineering intervention, ensuring design system integrity. It also highlights image optimization using the Next.js Image Component and Vercel's Edge optimization to improve user experience and page load times.
  34. Monorepos are changing how teams build softwareThis post explains the advantages of monorepos (easier updates, collaboration, local development, faster builds with remote caching) and positions Turborepo as a solution for adopting monorepos. It highlights Turborepo's zero-configuration remote caching for faster builds and CI runs, and provides examples of its impact on developer productivity and time savings.
  35. Monorepos are changing how teams build softwareThis post details how Turborepo's remote caching mechanism, when applied to Next.js projects, can reduce CI publish times by 80%. It highlights the elimination of cache purges and the enablement of eager pre-seeding of the remote cache, leading to faster iteration cycles. The post also emphasizes how Turborepo abstracts configuration and tooling, making monorepos more accessible and improving developer experience through faster builds and easier collaboration.
  36. Vercel acquires Turborepo to accelerate build speed and improve developer experienceThis post announces Vercel's acquisition of Turborepo, a high-performance build system for JavaScript and TypeScript codebases. It highlights Turborepo's capabilities in incremental builds, intelligent remote caching, and optimized task scheduling, which can boost build speeds by up to 85%. The acquisition makes Turborepo's CLI open-source and available for immediate use. Jared Palmer, the founder of Turborepo, joins Vercel to lead a team focused on build performance. The post emphasizes the benefits of monorepos and how Turborepo addresses their scaling challenges, with remote caching being a key feature leveraging Vercel's infrastructure.