CRUD vs Canvas UX: Why Software is So Frustrating But Will Improve

We’re all in a hurry, and this article will take 10 minutes to read. So here’s the summary right at the top of the article so you don’t need to get into all the details if you’ve got places to be, things to do, and people to meet*.

• Traditional software design relies on a user doing a series of small actions, each with their own entry points, which can be slow
• The more complex the task, the more time you spend looking for the right action, the less likely the feature exists, and the more likely task abandonment becomes
• Conversational UI like phone trees are extremely frustrating, but mostly because the technology was so bad for so long
• Now the technology is getting good, and traditional software design will soon seem as outdated, silly, and slow as a fax machine
• Thank you for attending my TED talk

CRUD: Create, Read, Update, Delete

Developers sometimes use the acronym CRUD to talk about the most basic building blocks of software. Imagine the main things you want to do with a todo list:

• Create a new item
• Read your todo list
• Update/edit an item
• Delete/mark as complete

But you’ll see the same pattern across software, whether Instagram, Tinder, or Excel. It all boils down to reading stuff, creating stuff, and editing it. Swipe right? That’s you U’ing your profile. Doomscroll social media? You’re R’ing the feed, until you decide to C a comment. Maybe you regret your comment, so you D it.

You see the same thing in games. You pick up a new sword, so your character used to be 32 strong, but that gets U’d to 37 strong. You walk into a new dungeon, so the system R’s the data to paint a picture for you. CRUD is everywhere, and it works very well in most cases we use every day.

Canvas UX

But not everything feels as limiting as CRUD. When you play MarioKart on a Nintendo Switch, you feel more in flow because your possible actions feel infinite. Technically, you can only accelerate or brake, turn right or turn left, and you should stay on the course. But experientially it doesn’t feel limiting, it feels freeing.

Drawing in Photoshop is similar in that it feels like an empty canvas. You can pick any brush and paint with it however you want. If you look at the creations of two people using Photoshop, they’ll look different. Not so for inboxes and todo lists. Canvas UX allows for freedom because it’s more than a bunch of settings toggling between true and false.

WIMP: Windows, Icons, Menus, Pointer

Another double-edged sword in software design is WIMP, an acyronym used to mean “Windows, Icons, Menus, Pointer.” This approach is great for giving you a single icon to tap on, where you know it will always do the same thing 100% of the time. It’s gloriously clear and simple … until it’s not.

Where WIMP fails us

1. Imagine looking at a list of 100 items. Say you want to select 3 of them. WIMP works great, because you just need to click 3 times. But what if you want to select all 100? Hopefully there’s a “select all” option. If not you’re going to be clicking 100 items yourself, which isn’t fun.
2. Have you ever bought airline tickets online for a family? You go to the site, type your destinations, then go through a lot of dropdown menus and fields for everything. If you have to edit the query, you often have to re-enter everything. What if you need a special meal? If there’s a special meal field, you’re in luck. If not, oh well. #WIMPlife
3. Or what about searching for things on Amazon? We type something into search, then spend a lot of time with knobs and dials on the left, trying to find the exact right filter to find a needle in a haystack. Apple or Samsung, four star reviews or higher, more than $300 but less than $900, on and on.
4. Or real estate. Or trying to get approved for a loan. Or filling out medical paperwork. The vast, vast majority of software assumes you’ll use a mouse or finger to trigger a single command, and you’ll do it again and again to communicate with the system until your query is complete. It’s a bit like painting with toothpicks. It’s technically possible but not efficient.

We’ve all been there, but I don’t think enough of us realise that software doesn’t have to be this frustrating. There are other paradigms beyond CRUD and WIMP. And they don’t have to be hard to use.

A real-world example of Canvas UX beating CRUD UX

While walking my dog, I started a voice conversation with chatGPT:

“Hey chatGPT, I’m stressed out and I have a long list of todos. I’m going to read everything on my mind to you, and I just want you to record everything, ok?”

It said ok, and over the next 5 minutes I narrated everything on my mind. Work stuff, personal stuff, family stuff, reminders of books I want to read, whatever. The official Getting Things Done book calls this a “brain dump,” and traditional software UX does a horrible job at it because a CRUD interface slows you down when you’re in this mindset. This is why talking out loud or jotting things in a sketchbook always feels better than navigating a whole bunch of textfields.

At this point, the software had everything on my mind, helpfully stored in its memory. It allowed me to “paint” on the canvas further, by saying:

“Hey, can you sort these items based on what you think is the biggest or hardest task? I want to make sure I focus my efforts on the most important stuff.”

And it did. For this rhetorical example, let’s say it said “It sounds like you need to focus on your board report and filing your taxes.” That’s a value judgement, so maybe it’s right and maybe it’s wrong. But now imagine trying to do that task with CRUD. It would be insanity, yet familiar to anyone who’s tried to do anything moderately complex on a computer with a CRUD and WIMP experience:

1. First wait until the dog walk is over, because complex data entry on a phone is difficult even when you’re looking at the screen, and not feasible while walking
2. Get to a computer with a keyboard so you can enter all the tasks
3. Once you have all the tasks, your todo app needs some way to add metadata, like labels or estimated effort fields
4. Then you’d need to manually tab your way through the software and add all the metadata yourself
5. With everything prepared, then you’d look for a way to sort by that metadata (and hope the feature had been built)

Designers often refer to things being “human-centered,” and those 5 steps are definitely not that. No one wants to walk through those steps, just like no one wants to churn their own butter. Traditional software makes this extremely difficult, to the point where only nerds do it. I’m sure churning your butter is a rewarding experience, but I will do everything in my power to never need to find out. That’s how non-nerds feel about using their computers for, well, everything. Most tasks are a disappointment, so we put up with them because we haven’t invented anything better. Yet.

Another quick example: cooking

I’ve been cooking a lot lately, especially with a wok. These days I take some vegatables, some protein, maybe some noodles or rice, set them on the counter, and take a picture of it. I send it to chatGPT and say:

“Here are my ingredients and I want to make stir fry. Tell me what order I should put everything into the wok, with timing and cooking instructions.”

That’s my entire process, and it results in a custom-made recipe for me, with perfect timing, based on the items on my counter. Halfway through, I might say “Oh, double this recipe” or “I’d like to make a spicy sauce that will go with this,” or anything else on my mind, and the instructions and recipes change immediately, perfectly suited to my situation.

Now compare that to doing the same thing with WIMP and CRUD. I’d search through the internet to find a recipe. (Side gripe: it would be cluttered with ads and extraneous information) I’d find something that looks promising, but notice I’m missing an ingredient. I’d maybe do a search for “can I replace x with y” on Google, then hem and haw based on the results I found on some reddit thread somewhere. It would be manual. It would be slow. It wouldn’t be based on me, it would be a one-size-fits-all approach that I’d have to tailor to myself, but I shouldn’t have to. And very soon, no one will. The change is already afoot, and it’s accelerating fast.

A note for my fellow product designers

Lots of very smart people have been writing very smart articles about how we can’t turn all software into chatbots. And I agree! Bots are frustrating. They’re too wobbly because it gives different answers sometimes, even for things that should stay consistent. And it’s too hard to become a “prompt engineer” to figure out how to type the right things to get the right answers.

Many of these posts argue that dropdowns, fields, and buttons are glorious because they only do one thing, communicate their intent clearly, and can’t just be replaced with an all-purpose text field. They’re right. Obviously no one wants all software to be a bot, and I think even AI-cheerleaders concede that point.

But if we can agree that not everything should be a text field, can we agree that not everything should be a series of radio buttons, dropdowns, and buttons, wrapped in bloated apps? Can we agree that CRUD makes a lot of things way too hard? Can we agree no one actually wants to install yet another dumb app, and they only begrudgingly do it because they’re trying to complete a task as quickly as possible, and the app is the only option they’ve found?

Check out this example:

curl -s “https://api.exchangerate-api.com/v4/latest/NZD" | jq ‘.rates.USD’

If you type that into your Terminal, it will convert the US Dollar to the New Zealand Dollar and return the answer, with the speed of calculator. Now imagine making that into an app. You’d probably do something like:

1. Make a new app called Translator.app
2. Design two dropdowns, one for each currency
3. Add a button
4. Connect it to a translation cloud service somewhere

And as a user, you’d have to follow similar steps:

1. Find and download the Translator.app product
2. Select USD for one dropdown, and NZD for the other
3. Press the button
4. Wait for the response

But that’s not where software is going. It’s too expensive to make, it’s too hard to use, and dropdowns are a UX crutch. You should be able to ask anything, Google or Siri style, of any software, in any way you want. You should be able to change the result in any way you want, whether translating to another language, comparing it to historical data, or even changing the UI itself on the fly. CRUD can’t do that. WIMP gets in the way of that. And it’s why software is so hard to use.

Take my examples from the beginning of the article, and imagine if we designed beyond textfields, buttons, and dropdowns:

1. If I wanted to select 100 items, I should be able to get the software to “Select all items,” or even “Select every other item in this list” or “Please select anything in this list that is gluten free,” or “Translate this to French.” It should all be possible, without any of these use cases requiring someone to design and build them into the code, then add yet another button or selection option to the UI.
2. If I wanted to buy airline tickets, I should look at a list of flights and make any change or learn anything easily. “I don’t want to fly through Sydney,” or “How much more expensive is this flight if I leave on Friday?” Today, this is technically possible, but far too difficult.
3. Same with online shopping. I should be able to say “Hey I found these 4 jackets, help me compare them.” Even across tabs. Even if the website is some indie Shopify site that hasn’t built a comparison option.
4. Real estate would let you look for esoteric things like “I don’t want to be near power lines,” medical searches would be able to cross reference your health history to more quickly find answers than you can skimming a giant list of symptoms on WebMD, and anything could have a “I didn’t understand that, can you explain like I’m five” option. (Not to mention an “is this a hoax” way to verify information)

Software is about to get a lot more accessible and helpful for a lot of people. And it’ll happen because we’re going to stop trying to shoehorn everything into buttons, dropdowns, and fields. We’ll get back to the original goal of software design: allowing people to do things they couldn’t before, with as little effort as possible.

*Bonus content

I put this post through a summarizer and got the below result. Read it and ask yourself: was the entire 2000 word article necessary, or does this concise summary do a good enough job for most people? If it’s good enough, what are the implications of that for your users and the interfaces we’re building?

The article “CRUD vs Canvas UX: Why Software is So Frustrating But Will Improve” outlines the limitations of traditional software design and the potential for improvement with emerging UX paradigms. Here are the main points:

1. Traditional Software Design Limitations: The article starts by critiquing the traditional CRUD (Create, Read, Update, Delete) model and WIMP (Windows, Icons, Mouse, Pointer) interface, which dominate software design. These models often result in a fragmented and inefficient user experience, especially for complex tasks. The user has to navigate through numerous small actions, which can be slow and frustrating.
2. Canvas UX: The article introduces the concept of Canvas UX, which offers a more fluid and flexible user experience. Unlike CRUD, which restricts users to predefined actions, Canvas UX allows for a more natural interaction with software, akin to painting on a canvas. This approach is compared to the experience of playing MarioKart or drawing in Photoshop, where the user feels more in control and less confined by the software’s limitations.
3. Conversational UI: The article highlights the potential of conversational user interfaces (UIs) as a more intuitive way to interact with software. Despite the frustration historically associated with conversational UIs like phone trees, advancements in technology are making them more viable and user-friendly. The author provides personal examples of using conversational AI (e.g., chatGPT) for tasks such as organizing to-dos or cooking, illustrating the efficiency and adaptability of this approach.
4. Future of Software Design: The article argues that the future of software design will move beyond the constraints of CRUD and WIMP towards more human-centered approaches like Canvas UX and conversational UIs. These emerging paradigms aim to make software more accessible and tailored to individual needs, ultimately reducing frustration and making tasks easier to accomplish.
5. Call to Action for Designers: The author calls on product designers to rethink the reliance on traditional design paradigms and consider the benefits of more flexible and intuitive interfaces. The article suggests that while not all software can or should be converted into chatbots, there is a significant opportunity to improve user experiences by adopting and integrating more adaptive and user-friendly design principles.

In summary, the article critiques the limitations of traditional software design models and advocates for a shift towards more intuitive, flexible, and human-centered UX paradigms to reduce user frustration and improve the overall software experience.

Me again. Thanks, robot! I think most people would agree that the summary is pretty good. Maybe the Medium.com of the future isn’t so CRUD-based, where I type a bunch of things into a textfield (C)and you read(R) it on a white background. Maybe it’s more canvas-based, where you get the main gist across topics in whatever way you want, with less friction, adjusted to your own accessibility needs. It’s hard to know exactly how that will shake out, and it’s terrifying for writers, but the interface with the least friction always has a good chance at winning.