Skip to main content

Reflections on an ATM's User Interface Sequence

While at my local bank today, I had an unpleasant end-user experience with the user interface for their automated teller machine.

My goal was to deposit 10 cash bills into my account, an action I have performed many times before.

This series of lived-out Use-Cases started out well: a blinking light prompted me to begin by inserting my bank card in the adjacent slot. Very nice and clear. I entered my PIN on the large-button key pad and successfully and easily logged in.

Next, I used the touch-screen to select my action (Deposit), my account (Savings), and the deposit format (Cash). The ATM promised to count the stack of bills and determine the exact amount of the deposit.

That's where the problems began.


The "Deposit Cash" sequence of events now expects the user to insert the stack of bills into another slot, indicated both graphically on the touch-screen and by another blinking light.

But when I inserted my stack, whose total number of bills was well under the posted maximum number of bills the slot can handle, the hardware failed to draw them in for analysis and recognition. The mechanism that drew them in successfully pulled in the top bill, but only partially accepted the remaining ones.

The ATM switched to Error mode and its Return Cash use-case, so I took back the bills that had failed to insert and, after a few seconds, it returned the one bill it had captured.

I backed up in the process, smoothed the bills, and tried again. Same result. I gave it a third attempt with the same failure result again. In good baseball fashion, I considered three strikes to be out.

Problem #1 was a hardware failure to accept the stack of bills. In their favour, the error produced a clear message and easy restoration of the start state.

Problem #2 was that, unfortunately, there were no indications of what I could do to avoid the error and get the machine to accept my cash. I retried exactly the same thing 3x because it gave me no instructions on what I could do differently.

Problem #3 was a lack of other options. I like the high-tech ability to do a no-envelope cash deposit, one that promises easier and quicker access to deposited funds with less time that the bank considers the finds on hold.

But by going envelope-free, there were... no envelopes. I don't think the ATM even had a slot for such an input. It had to accept my cash or my deposit would have to wait until I could deal with a human teller, a privilege for which some banks charge a small fee. if the technology rejects the deposit, how can it be completed?

I decided to try one more time, but this time I would take my small stack of bills and insert it in stages, as even smaller stacks of bills.

Aha! Success! I fed half of them, 5 bills, in the first try, and the ATM accepted them, correctly identified and summed them and displayed my deposit total.

But when I readied the second set of 5 bills, I discovered that I could not add them to the same deposit. There was lots of screen space to add more entries, but the use-case flow as implemented required that I Confirm the deposit amount, Choose whether or not to print a Receipt, and Choose whether or not I had any other transactions to do.

For the second half-stack of bills, I had to start the Deposit process all over again. For the 5th time.

Problem #4 was that the deposit sequence accepted only a single bunch of things. It did not allow for a deposit of mixed modalities - e.g. Cash and Cheque; it did not allow for multiple stacks of cash.

I can imagine there are real reasons for many of these limitations I encountered today, but I was left frustrated that the sleek machine, touch screen, and user interface forced me to start over so many times.

An exercise for the reader: How would you design differently the processes involved in this scenario?








Popular posts from this blog

Git Reset in Eclipse

Using Git and the Eclipse IDE, you have a series of commits in your branch history, but need to back up to an earlier version. The Git Reset feature is a powerful tool with just a whiff of danger, and is accessible with just a couple clicks in Eclipse. In Eclipse, switch to the History view. In my example it shows a series of 3 changes, 3 separate committed versions of the Person file. After commit 6d5ef3e, the HEAD (shown), Index, and Working Directory all have the same version, Person 3.0.

Scala Collections: A Group of groupBy() Examples

Scala provides a rich Collections API. Let's look at the useful groupBy() function. What does groupBy() do? It takes a collection, assesses each item in that collection against a discriminator function, and returns a Map data structure. Each key in the returned map is a distinct result of the discriminator function, and the key's corresponding value is another collection which contains all elements of the original one that evaluate the same way against the discriminator function. So, for example, here is a collection of Strings: val sports = Seq ("baseball", "ice hockey", "football", "basketball", "110m hurdles", "field hockey") Running it through the Scala interpreter produces this output showing our value's definition: sports: Seq[String] = List(baseball, ice hockey, football, basketball, 110m hurdles, field hockey) We can group those sports names by, say, their first letter. To do so, we need a disc

Java 8: Rewrite For-loops using Stream API

Java 8 Tip: Anytime you write a Java For-loop, ask yourself if you can rewrite it with the Streams API. Now that I have moved to Java 8 in my work and home development, whenever I want to use a For-loop, I write it and then see if I can rewrite it using the Stream API. For example: I have an object called myThing, some Collection-like data structure which contains an arbitrary number of Fields. Something has happened, and I want to set all of the fields to some common state, in my case "Hidden"

How to do Git Rebase in Eclipse

This is an abbreviated version of a fuller post about Git Rebase in Eclipse. See the longer one here : One side-effect of merging Git branches is that it leaves a Merge commit. This can create a history view something like: The clutter of parallel lines shows the life spans of those local branches, and extra commits (nine in the above screen-shot, marked by the green arrows icon). Check out this extreme-case history:  http://agentdero.cachefly.net/unethicalblogger.com/images/branch_madness.jpeg Merge Commits show all the gory details of how the code base evolved. For some teams, that’s what they want or need, all the time. Others may find it unnecessarily long and cluttered. They prefer the history to tell the bigger story, and not dwell on tiny details like every trivial Merge-commit. Git Rebase offers us 2 benefits over Git Merge: First, Rebase allows us to clean up a set of local commits before pushing them to the shared, central repository. For this

Code Coverage in C#.NET Unit Tests - Setting up OpenCover

The purpose of this post is to be a brain-dump for how we set up and used OpenCover and ReportGenerator command-line tools for code coverage analysis and reporting in our projects. The documentation made some assumptions that took some digging to fully understand, so to save my (and maybe others') time and effort in the future, here are my notes. Our project, which I will call CEP for short, includes a handful of sub-projects within the same solution. They are a mix of Web APIs, ASP MVC applications and Class libraries. For Unit Tests, we chose to write them using the MSTest framework, along with the Moq mocking framework. As the various sub-projects evolved, we needed to know more about the coverage of our automated tests. What classes, methods and instructions had tests exercising them, and what ones did not? Code Coverage tools are conveniently built-in for Visual Studio 2017 Enterprise Edition, but not for our Professional Edition installations. Much less for any Commun