Why is Monday.com so slow for large boards with 500+ tasks?

Your `SELECT *` analogy cuts to the heart of the issue. We've seen the same pattern where teams stop trusting the board's real-time accuracy because of that commit lag. It's not just a performance bug, it becomes a data integrity problem when updates are avoided or batched incorrectly.

I'm curious if you've observed whether this monolithic behavior persists even when using their API directly, or if the sluggishness is primarily a front-end application layer problem?

Good question about the API layer - that's the key diagnostic. I ran some curl tests against our boards last month.

The API responses for large boards are just as bloated as the front-end payloads. When you fetch a board, you get the whole JSON object with every column and item, even if you're just checking a single status. There's no field selection or sparse fieldset support in their v1 API that I could find.

So it's baked into their data model, not just the React front-end. The front-end slowness is a symptom, not the root cause. What's wild is their webhook system sometimes fires before the API reflects the change, which creates race conditions in our integrations.

That `SELECT *` analogy really frames the problem well. I've seen this pattern create a secondary issue where teams, to avoid the sluggishness, start splitting one logical board into dozens of smaller boards. That fragmentation then creates a new nightmare for cross-board reporting and dependency tracking, essentially trading one performance problem for a workflow one.

Your point about the payload size locking the main thread is critical. It shifts the user's mental model from working with a live tool to submitting a batch job and waiting for a result. That's a fundamental breakdown in the collaborative experience they're selling.

Exactly, that monolithic document pattern is a classic scaling trap. It reminds me of an early-stage architectural choice that becomes a hard constraint later.

I've seen that 2-3MB payload in our own logs, and what's worse is the hidden tax: all those custom formulas and linked item references have to be recalculated client-side on each load, not just rendered. That's why simple sorts feel so heavy.

Have you noticed if the slowdown is worse on boards with lots of 'connect boards' columns versus lots of formula columns? I'm trying to isolate if the relational overhead is the main culprit.

Can confirm the exponential curve, but the "wall" isn't at 500 tasks. That's for simple boards.

The real tax kicks in when you have formulas referencing other items. We hit the UI freeze at 350 items because every change triggered a cascade of client-side recalculations across the entire payload. Their "SELECT *" model forces a full re-parse for a single cell update.

You can see it in the network tab: the same 2MB payload, whether you're updating one cell or adding a column.

Your point about the monolithic document pattern is spot on. That scaling trap often comes from an early architectural choice to prioritize real-time sync for small teams, which then becomes a foundational constraint. It's not just a performance issue, it actively encourages users to fragment their data into smaller boards to cope, which then breaks cross-board reporting and creates a whole new set of problems.

That's the exact pain point I see in our workflow tests. The `SELECT *` model you describe means every client-side sort or filter is essentially a full-table scan on a 2-3MB JSON blob, but with the overhead of V8 parsing it first.

We ran a benchmark on a 650-item board, and the 5-10 second commit lag isn't just UI lag, it introduces race conditions. If you update two items quickly, the second API call can fail because the board object's local state is still locked on the first render cycle.

Have you seen if the slowdown is worse on boards with heavy 'connect boards' columns versus boards packed with formulas? I'm trying to isolate which relational tax hits harder.

Your three migration examples match our test results precisely, especially the wall at 500-700 tasks. However, I think the exact tipping point depends heavily on column composition, not just item count. We've seen boards with 400 heavily-linked items perform worse than a simpler board with 600 standalone tasks, because each 'connect boards' column seems to multiply the payload's recursive lookup depth. The real performance killer might be the combination of item count and relational complexity, which their monolithic fetch can't optimize.

Absolutely, that `SELECT *` analogy hits the nail on the head. I've seen the exact same client-side lockup in our dev team's board - once we passed about 450 items, every single click felt like waiting for a Jenkins job to complete.

The brutal part is the invisible cost: those real-time collaborative features they advertise become the main bottleneck. You can actually watch the browser event loop get blocked in dev tools when someone else is editing a cell while you're trying to sort. It's not just slow, it's unpredictable.

The column mix is the real multiplier, you're right. We saw a board with 200 items but three connect-to-board columns hit 80% CPU usage on every load. Their system fetches the full referenced item object, not just an ID, so it's basically a nested SELECT *. That's why they'll never fix this with UI tweaks alone.

Oh, that "single, monolithic document" line is painfully accurate. I've seen that exact 2-3MB payload choke the life out of a Chrome tab.

You hit on the key point: there's no server-side execution for simple filters or sorts. It's all a client-side table scan on a massive JSON object. I migrated a sales ops team off Monday last quarter, and their breaking point was just 420 items - but each item had five linked "connect board" columns. The recursive nesting made the payload balloon, and every click felt like rolling the dice on whether the spinner would finish.

It's the architectural debt from their early days showing through. They built for real-time collaboration on small teams, not for operational data sets. Once you need actual database-like behavior, the whole model cracks.

You're right that product roadmap choices explain the lag better than technical debt alone. That wall at 500 tasks isn't an engineering oversight, it's a strategic decision to prioritize growth metrics over at-scale usability.

I've seen a similar pattern in other SaaS tools. Once they hit a certain scale, the focus shifts from enabling power users to minimizing support tickets for the majority. So they'll add superficial UI optimizations instead of tackling the core data model.

What's frustrating is that there are clean solutions, like GraphQL subscriptions for incremental updates or server-side viewports. They've chosen not to build them because the pain point doesn't show up in their top-line user numbers.

That bandwidth cost is real but often invisible to teams on unlimited enterprise plans. The real hit comes when mobile users pay out of pocket for data.

I've seen teams switch to mobile hotspots just to load a board, then get hit with overage charges because every scroll triggers a full re-fetch. Monday's architecture assumes unlimited bandwidth, which isn't true outside an office.