Retool Nested Folders: Organizing Apps and Queries at Scale

If you've ever tried to wrangle dozens of Retool apps into a clean folder structure, you've already hit the wall: Retool nested folders don't exist yet — at least not fully. The current folder system is flat, meaning you can create top-level folders, but you can't put a folder inside a folder. For small teams with a handful of apps, that's fine. For anyone running a growing internal tools practice, it becomes a real problem fast.

What Retool's Current Folder System Can and Can't Do

Right now, Retool gives you one level of folders to organize your apps on the home screen. You can create a folder called Finance or Operations and drag apps into it. That's it. You cannot create Finance > Accounts Payable > Invoicing or any other nested hierarchy.

The same limitation applies inside apps. When you open an app and look at the query panel, you can group queries into folders — but again, only one level deep. There's no way to create a subfolder inside a query folder. So a structure like:

• Users
  • Admin
    • createAdminUser
  • NonAdmin
    • createStandardUser

...is simply not possible today. You're stuck with a single flat list of query folders, which starts to become unmanageable once you hit 20–30 queries in a complex app.

And then there's the Query Library — Retool's shared resource for reusable queries across apps. Currently, the Query Library has zero folder support. No folders at all. As your library grows, it turns into an unsorted pile of queries with no way to group them by feature, team, or data source.

Why Retool Nested Folders Matter for Real Projects

The lack of nested folder support isn't just a minor inconvenience — it's a scaling problem. Here are the scenarios where it bites hardest:

• Large app portfolios: Agencies or internal teams managing 50+ apps across multiple business units can't create meaningful sub-groupings. Everything ends up in a handful of overloaded top-level folders or, worse, ungrouped entirely.
• Complex apps with many queries: An app that handles users, billing, notifications, and reporting can easily accumulate 40+ queries. Without nested folders, all of those live in one flat list, making it hard to find anything quickly.
• Mobile vs. web variants: Teams building both mobile and web versions of internal tools want to organize by project name and then by platform — a two-level hierarchy that's impossible today.
• Shared Query Library governance: As teams add more shared queries to the Query Library, there's no way to signal which queries belong to which domain, team, or integration.

What Retool Has Said About the Roadmap

This has been one of the most consistently upvoted requests in the Retool community, with threads dating back several years. As of the most recent public update from the Retool team, nested app folders are actively in progress. The work was described as "fairly complex," and an end-of-Q1 target was mentioned — though no hard release date has been committed to publicly.

Nested folders for in-app query organization and Query Library folders were acknowledged as separate requests that had not yet entered active development at the time of the last update. These remain open feature requests with significant community support.

How to Stay Organized in Retool Right Now

While you wait for nested folder support to ship, here are practical conventions that reduce the pain:

• Use naming prefixes as pseudo-namespacing: Name your apps and queries with a consistent prefix pattern, like finance__ap__invoice_lookup or users__admin__create. It's not pretty, but it makes search more useful and signals hierarchy visually.
• Limit query scope per app: Rather than building one massive app with 50 queries, break functionality into focused apps that each do one thing well. This naturally limits how many queries any single app accumulates.
• Document your Query Library: Use descriptive, consistent names in your Query Library — include the data source, action, and domain in every name (e.g., postgres__users__getByEmail). When folders arrive, you'll be able to sort them quickly.
• Group by team or domain at the top level: Use Retool's existing single-level app folders to at least separate major domains — Finance, HR, Engineering — even if you can't go deeper yet.
• Use Retool Spaces (if on a plan that supports it): Some teams use separate Retool Spaces or environments to create logical separation between major product areas, which partially compensates for the lack of deep folder hierarchies.

What to Do When Nested Folders Ship

When Retool rolls out nested folder support, migrating a disorganized workspace will take real effort. Getting ahead of it now makes that migration much easier. Establish a folder taxonomy today — even if you can only implement the top level — so that when nested folders arrive, you're adding depth to an existing structure rather than building from scratch.

A good starting taxonomy for most teams looks something like: Team or Domain > Project > App Type (web/mobile). Document it in your internal wiki now, get your team aligned, and enforce naming conventions as you create new apps and queries.

The Bottom Line

Retool's flat folder system is a known limitation that the team is actively working to fix. Nested folders for apps are in progress; nested query folders and Query Library folders are next in line. In the meantime, strict naming conventions and keeping apps focused and small are your best tools for staying organized. When the feature ships, teams that planned ahead will be able to adopt it immediately — everyone else will be stuck doing cleanup.