Colocation: Organizing Files in Next.js 14

Anton Ioffe - November 14th 2023 - 10 minutes read

In the ever-evolving landscape of JavaScript and modern web development, Next.js 14 stands as a testament to innovation, steering developers towards a more intuitive and structured codebase. This article delves into the art of colocation—the strategic organization of files and route management, reinforcing Next.js’s filesystem-based routing with finesse. We embark on a journey through the enhanced routing mechanics, ingenious use of the src directory, modular encapsulation tactics, and pragmatic file segmentation, all while demystifying pioneering colocation patterns that intertwine with the fabric of Next.js 14. Whether you’re architecting a new project or refactoring an existing one, prepare to unlock the secrets of efficient file organization and adaptable structures that promise to refine your development process and fuel your curiosity to traverse the full extent of Next.js’s latest features.

Fundamental Mechanics: Filesystem-Based Routing in Next.js 14

Next.js 14 continues to build upon the powerful foundation of filesystem-based routing, ensuring that developers can intuitively map out their application's navigation architecture. With its latest updates, this mechanism allows for a level of precision that further tightens the relationship between the filesystem and executed routes. To grasp the improvements Next.js 14 introduces, consider the refinement of nested layouts. This feature recognizably taps into the filesystem hierarchy, allowing developers to place layout components that encapsulate a section of their site directly within the directory structure. This leads to a chain of layouts that naturally reflect the nested nature of UI components — a clear manifestation of the filesystem’s mirroring of the UI structure.

Within this context, server components in Next.js 14 showcase the routing system's versatility. By utilizing server components, which render on the server and send minimal interaction code to the client, filesystem-based routing enables a clean division of logic and presentation. The delineation is straightforward: files designated as server components live alongside route files, making them inherently part of the routing system. This reinforces the concept that routes are not just paths or endpoints but can also represent modular functionality encapsulated within a specific context and directory.

However, the simplicity of Next.js's filesystem-based routing should not overshadow the architectural complexity it can support. Although dynamism in routes — such as catch-all routes or optional catch-all routes — offers a gateway to creating powerful, parameter-driven pages, Next.js 14 doesn’t let this convenience dilute the underlying sophistication of the routing system. By striking a balance between ease and capability, it allows for a wide spectrum of designs, from static pages to highly dynamic, data-driven applications, all within the same coherent routing paradigm.

Developers should appreciate the finesse with which Next.js 14 has handled the trade-offs between convention and configuration. While convention, in this case, is guided by the filesystem, the configuration is subtly woven into filename and directory patterns. As developers explore the architecture of a Next.js 14 application, the file system's role in dictating routing behavior becomes unmistakable, with an almost declarative syntax that emerges from the mere organization of files and directories.

As we proceed further into the labyrinthine possibilities that filesystem-based routing unfolds, we must acknowledge the intuitive nature of Next.js 14's approach. Bringing together the composability of server components, the hierarchical power of nested routes, and the straightforward mapping of filesystem to routes, it constructs a streamlined development experience. This foundation paves the way for more advanced implementations that harness the full potential of Next.js 14's flexible routing — culminating in a robust, maintainable, and scalable web application.

Laser-focused Alias Strategy: The Power of the src Directory

Adopting a src directory within a Next.js codebase significantly enhances developer ergonomics by centralizing application source files, thereby decluttering the project's root. This strategic move separates app-specific code from configuration files and static assets, making it easier for developers to navigate large projects. The key is that all application-relevant material lives inside src, which simplifies the structure. This structural clarity is not just about aesthetics; it helps new developers onboard quicker, reduces cognitive load when looking for files, and promotes a more organized development experience.

With this foundation, Module Path Aliases come into play as a game changer, vastly simplifying import statements. Instead of relying on complex relative paths that can become unwieldy in deeply nested project structures, developers can define aliases in tsconfig.json or jsconfig.json. These aliases act as shorthand references to specified directories, so imports become cleaner and less error-prone. For example, @components/button is much more readable and maintainable than ../../../../../components/button. This approach also reduces the likelihood of errors during refactoring when files or directories move, as the alias remains constant.

However, with great power comes great responsibility. Overuse or misuse of path aliases can lead to ambiguity and complications in understanding the codebase structure. It is crucial to define aliases that are intuitive and map logically to the directory structure. A sparse, laser-focused alias strategy where each alias reflects a clear and distinct area of the codebase is essential. Creating too many aliases, especially overly granular ones, can backfire, leading to confusion over what each alias refers to and unnecessary overhead in alias management.

When scaling applications, consider grouping related functionalities under broader aliases. If @components points to common components, @modules could group feature-specific modules, and @content could encapsulate assets and static data. This approach strikes a balance between overgeneralization and excessive detail. Aliases should grow with the application and be revisited regularly. As the codebase evolves, so should the strategy guiding alias creation, ensuring it continues to serve the goal of maintainability and clarity.

In practical terms, leveraging aliases should be a thoughtful process. For instance, creating a naming convention that aligns with the project’s vocabulary can go a long way. Establishing patterns such as @components/* to src/common/components/* and @styles/* to src/common/styles/* standardizes file location without having to remember the underlying directory paths. This consistent strategy facilitates better tooling integration and fosters a more intuitive understanding of the codebase layout. It’s important to remember that, ultimately, aliases are there to aid development, not to create a labyrinth of shortcuts that obfuscate the true structure of the project.

Encapsulation and Modularity: The Role of Private Folders and Route Groups

Understanding the underlying structure of a Next.js application begins with recognizing the distinction between routable components and encapsulated modules. Private folders, denoted by an underscore prefix, play a crucial role in encapsulation: they opt out any enclosed files from being served as routes. These folders are especially valuable for segregating UI logic from routing logic, preventing route naming conflicts, and neatly organizing auxiliary code, such as services, utilities, or components, which are not directly tied to specific routes.

In contrast, route groups are demarcated by parentheses and enable logical grouping of routes without altering the actual URL structure. They enhance modularity by allowing developers to arrange files that align with particular aspects of the application's interface or functionality. This is particularly advantageous in complex directory structures as seen in large-scale applications, where various teams may manage different app segments.

The compartmentalization within private folders enables developers to encapsulate all related business logic, styles, tests, and sub-components, regardless of the proximity to routable files. This principle not only isolates concerns but also permits the reusability of stand-alone modules throughout different parts of the application, circumventing any unintended routing repercussions.

By utilizing these features, encapsulation in the app directory is transformed into a deliberate architectural choice rather than a byproduct of file organization. Colocating files by default promotes code cohesion, yet the strategic employment of private folders introduces clarity into the potential disarray, distinguishing which code segments handle routes and which are exempt. This approach upholds the conventions set out by Next.js but also provides the flexibility necessary for developers to effectively structure their application's architecture.

The synergy between private folders and route groups carves out a structure where every element has its designated place, maintaining an equilibrium between order and flexibility. With these features, developers can optimally organize their applications for better maintainability, scalability, and navigational ease, ensuring that each file serves its intended purpose efficiently and without confusion.

Streamlined File Organization: Feature and Route-Based Segmentation in Practice

When organizing files within a Next.js project, either by feature or by the associated route, understanding the distinction between the two is paramount. Starting with feature-based segmentation, this method places emphasis on grouping related functionalities. Consider the authentication feature, which may include a series of files like signIn.js, signOut.js, authHook.js, and authContext.js. These files, cohesively addressing the authentication aspect, can be organized under an auth directory within the app folder. Here is an example of how the structure would appear:

├─ auth/
│  ├─ signIn.js
│  ├─ signOut.js
│  ├─ authHook.js
│  └─ authContext.js
├─ pages.js // Entry point for the route

In contrast, route-based segmentation aligns with the specific endpoints of the web application. Assuming you have a route for user profile settings, you would structure the route-related files in a directory reflecting the path, such as app/user/settings. This would not only include the page component but also related hooks, components, and even styles specific to that route:

├─ user/
│  ├─ settings/
│  │  ├─ index.js // Page rendering at /user/settings
│  │  ├─ useSettingsForm.js // Hook for form logic
│  │  ├─ settingsForm.js // Component for the settings form
│  │  └─ settings.module.css // Styles specific to settings page

Feature-based segmentation shines in promoting reusability and maintainability, as the related files are unified by their shared functionality rather than their place in the route hierarchy. This makes it easier to locate all the logic and components concerning a particular feature of the application. However, this can also lead to densely populated directories as the application grows, which might affect the readability of the structure.

Route-based organization excels in representational clarity, as developers can easily discern which files render for a given URL path, enhancing the testability of each route's components in isolation. Yet, it can result in duplication of logic and components if the same functionalities are needed across different routes, complicating the modularity of your codebase.

A crucial coding error often seen in practice is the spread of route-related logic across the application. When organizing files by route, one must resist the urge to scatter pieces of page logic outside of its directory, which bloats the project and hampers maintainability. For instance:

// Incorrect: The useUserProfile logic is placed outside of the user profile route directory
├─ hooks/
│  └─ useUserProfile.js // This hook relates specifically to the user profile route
├─ user/
│  └─ profile/
│     └─ index.js

// Correct: Colocating the useUserProfile hook inside the profile directory ensures better organization
├─ user/
│  └─ profile/
│     ├─ index.js
│     └─ useUserProfile.js

Finally, while considering these organizing principles, a thought-provoking question for developers might be: How can you decide on a balance between feature-based and route-based organization in a way that enhances both the reusability of components and the specificity of routes for a large-scale Next.js application?

Best Practices in Colocation: Pioneering Patterns and Steering Clear of Antipatterns

Embracing the advances of Next.js 14, developers are innovating with colocation patterns that streamline their project architectures. A sophisticated practice involves architecting directories around the concept of 'domains'. Domains are broad areas of functionality, such as 'user', 'billing', 'product', encapsulating all relevant logic, UI components, and services. For instance, within the 'user' domain, one might find components like UserProfile.jsx, alongside userHelpers.js and userStyles.module.css. By bundling related files, this pattern maintains code cohesiveness and ease of navigation.

// user/UserProfile.jsx
import React from 'react';
import useUser from './useUser';
import styles from './userStyles.module.css';

const UserProfile = () => {
    const user = useUser();
    // User profile logic
    return <div className={styles.profile}>...</div>;
export default UserProfile;

A frequent antipattern that undermines the benefits of colocation is the overgeneralization of components or utilities that, although shared across domains, are scattered without a clear strategy. This diminishes the advantage colocation brings. The antidote is crafted shared directories that house common components or utilities used across different domains, such as shared/ui-components or shared/utils, ensuring the accessibility and reusability of widespread resources without compromising on structure.

// shared/ui-components/LoadingSpinner.jsx
import React from 'react';
import './loading-spinner-styles.css';

const LoadingSpinner = () => (<div className="spinner">Loading...</div>);
export default LoadingSpinner;

Moreover, with the ascendancy of hooks in React, colocation extends to custom hooks, which are best kept alongside their most directly related components. This confluence between logic and rendering leads to an increase in maintainability. However, it is not uncommon to witness the misstep of interspersing hooks throughout the project, undermining their discoverability. Well-crafted colocation aligns hooks with the feature or route that predominantly depends on them, while common hooks gravitate towards a central 'hooks' directory.

// product/useProduct.js
import { useState, useEffect } from 'react';

export const useProduct = productId => {
    const [product, setProduct] = useState(null);
    // Product fetching logic using productId
    useEffect(() => {
        // Fetch product and set state
    }, [productId]);
    return product;

Another burgeoning practice concerns the treatment of tests in a colocated environment. By situating test files next to their associated component or utility, developers reinforce the association between code and verification, thereby streamlining the development and refactoring processes. Conversely, placing test files in separate, mirrored directory structures not only burdens the developer with navigating across complex directory topologies but also increases the overhead of maintaining these parallels as the application evolves.

// user/__tests__/UserProfile.test.jsx
import React from 'react';
import { render } from '@testing-library/react';
import UserProfile from '../UserProfile';

test('renders user profile correctly', () => {
    const { getByText } = render(<UserProfile />);
    // Assertions for UserProfile component

Injecting thoughtfulness into colocation practices requires asking whether the organization of files and directories aligns with the mental model of the domain, enhances productivity, and augments the application's scalability. Does the colocated structure boost team collaboration and agile development, or does it necessitate frequent refactoring to find an efficient workflow? As you advance your Next.js project, these considerations form the blueprint of a project's long-term success and the developer experience therein.


In this article, the author explores the concept of colocation in Next.js 14 and its impact on file organization in modern web development. The article emphasizes the benefits of filesystem-based routing, the power of utilizing the src directory and module path aliases, the role of private folders and route groups in encapsulation and modularity, and the importance of feature and route-based segmentation. The key takeaway is that by strategically organizing files, developers can enhance maintainability, scalability, and navigational ease in their Next.js applications. As a challenge, readers are encouraged to consider how to strike a balance between feature-based and route-based organization to achieve optimal reusability and specificity in a large-scale Next.js application.

Don't Get Left Behind:
The Top 5 Career-Ending Mistakes Software Developers Make
FREE Cheat Sheet for Software Developers