Category Archives: Usability

Posts related to product design, user experience and usability.

How we work with 2-week Sprints

Agile & Scrum, Kerika, Team Collaboration, Technology, Usability, , , ,

Here at Kerika, we often get asked how we do Scrum as a distributed team.

Here’s the model we have evolved, which works for us mainly because we are the very essence of a distributed Agile team: we have people working together on the same product from locations that are 10,000 miles apart!

And this means that we are the most enthusiastic consumers of our products: we use Kerika to manage every part of our business and we only build what we would ourselves love to use.

Here’s the basic outline of our Scrum model:

Kerika's model for 2-week Sprints
Kerika’s model for 2-week Sprints

Each Sprint is 2 weeks long: that that works well for us; other folks might find that 3 weeks or 4 weeks i better. Pick what works for you.

Each Sprint begins with Sprint Planning, where the Scrum Team gets together with the Product Owner to decide which cards will be pull from our main Product Backlog into the Sprint Backlog.

Each Sprint is organized as a separate Scrum Board: this makes it really easy for us to concentrate upon needs to get delivered in that particular Sprint, without getting distracted by what was done in the past or what remains to be done.

And Kerika makes it really easy to pull cards (literally!) from the Backlog onto a Scrum Board, and then hide the Backlog from view so it doesn’t distract the Team while the Sprint is underway.

Half-way the Sprint, at the end of the first week, we do a gut-check: does the Sprint look like it is going reasonably well? We don’t ask if it is going perfectly: almost no Sprint does; what we are looking for is any indication that the Sprint is going to severely under-deliver in terms of the Team’s commitments to the Product Owner.

We could do these gut-checks every day during our Daily Standups, but in the first part of a Sprint cycle these can often give us false positives: it’s easy to tell early on if a Sprint is going to be disastrous, but it’s hard to tell for sure that it is actually going to end well. But about midway through the Sprint we start to have a more reliable sense for how things may turn out.

In keeping with the Scrum model, our goal is to complete a potentially shippable set of features and bug fixes with each Sprint, although this doesn’t necessarily mean that we will always ship what gets built after each Sprint. (More on that later.)

For each feature or bug, however large or small, we make sure that we have design and testing baked into the process:

  • The document is often just a few paragraphs long, because we always take cards representing large features (or other big work items) and break them up into smaller cards, so that no card is likely to take more than a day’s work. Kerika makes it really easy to link cards together, so it’s easy to trace work across multiple cards.
  • For bugs, the attached document describes the expected behavior, the actual behavior, and the root cause analysis.  Very frequently, screenshots showing the bugs are attached to the cards.
  • For new features, several documents may be attached, all quite small: there may be a high-level analysis document and a separate low-level design document.
  • For all features and bugs, we do test planning at the time we take on the work: for back-end (server) work we rely primarily on JUnit for writing automated tests; for front-end (UI) work we have found that automated testing is not very cost-effective, and instead rely more on manual testing. The key is to be as “test-driven” in our development as possible.

There are several benefits from doing formal planning, which some folks seem to view as being antithetical to an Agile model:

  • It helps find holes in the original requirements or UI design: good technical analysis finds all the edge cases that are overlooked when a new feature is being conceptualized.
  • It helps ensure that requirements are properly interpreted by the Team: the back-and-forth of analysis and reviewing the requirement helps ensure that the Product Owner and the Team are in synch on what needs to get done, which is especially important for new features, of course, but can also be important to understand the severity and priority of bugs.
  • It deliberately slows down the development pace to the “true” pace, by ensuring that time and effort for testing, especially the development of automated tests, is properly accounted for. Without this, it’s easy for a team to quickly hack new features, which is great at first but leads to unmaintainable and unstable code very soon.

At the end of the 2-week cycle, the Team prepares to end the Sprint…

We like to talk about Sprints as “buses”: a bus comes by on a regular schedule, and if you are ready and waiting at the bus stop, you can get on the bus.

But if you are not ready when the bus comes along, you are going to have to wait for the next bus, which thankfully does come by on a regular 2-week schedule.

This metaphor helps the Team understand that Sprints are time-boxed, not feature-boxed: in other words, at the end of every 2 weeks a Sprint will end, regardless of whether a feature is complete or not.  If the feature is complete, it catches the bus; otherwise it will have to wait for the next bus.

And here’s where the Kerika team differs from many other Scrum teams, particularly those that don’t consume their own products:

  • At the end of each Sprint, we do the normal Sprint Retrospective and Show & Tell for the Product Owner.
  • But, we also then take the output of the Sprint and deploy it to our test environment.
  • Our test environment is the one we actually use on a daily basis: we don’t use the production environment as often, preferring to risk all of our work by taking the latest/greatest version of the software on the test environment.

This forces us to use our newest software for real: for actual business use, which is a much higher bar to pass than any ordinary testing or QA, because actual business use places a higher premium on usability than regular QA can achieve.

(And, in fact, there have been instances where we have built features that passed testing, but were rejected by the team as unusable and never released.)

Kerika's model for 2-week Sprints
Click on this image to see the actual Kerika Whiteboard

This is illustrated above: the version of Kerika that’s built in Sprint 1 is used by the team to work on Sprint 2.

This is where the rubber meets the road: the Kerika Team has to build Sprint 2, while using what was built in the previous Sprint. If it isn’t good enough, it gets rejected.

At the end of Sprint 2, we will release the output of Sprint 1 to production. By this time it will have been used in a real sense by the Kerika Team for at least 2 weeks, post regular QA, and we will have a high confidence that the new features and bug fixes are solid and truly usable.

We could summarize our model by saying that our production releases effectively lag our Sprint output by one Sprint, which gives us the change to “eat our own dogfood” before we offer it to anyone else.

You can see the actual Whiteboard project for this process flow here.

 

 

Improving Kerika on iPads

Technology, Usability

Remember: you don’t need an app to use Kerika on iPads: you can simply use Safari or Chrome — just go to to kerika.com, and login just like you would on a desktop.

Kerika on iPad
Kerika on iPad

What’s great about building a pure HTML5 software like Kerika is that many of these improvements are also going to improve the user experience on desktops and laptops.

Here’s the laundry list:

Big changes:

  • You can add photos from your iPad to cards: you can take existing images from your photo library, or simply take a picture on the go and add it to a card.
  • We worked out a bunch of quirks related to Internet Explorer, which, unfortunately, remains sui generis when it comes to browsers.
  • In general, Kerika is now a lot smarter about dealing with laptops that have both mouse and touch interfaces.
  • We have improved performance and responsiveness, across the board.

Usability improvements:

  • We have redesigned our “Max Canvas” view so that it provides the most useful display, when you need the most space available to view a large board. In particular, you can now access Search even when you are in the Max Canvas view.
  • If a column is partially hidden, e.g. at the left- or right-edge of a Task Board or Scrum Board, clicking on the “+New Card” button at the bottom of the column will make the entire column slide into view, so you can clearly see what you are typing.
  • The Yes/No confirmation buttons on the Workflow dialog have been resized, so they are easier to press (unambiguously) with a finger on a tablet. Which, of course, improves usability for laptop users as well, in keeping with Fitt’s Law.
  • On a related note, we rescaled the calendar control used for setting due dates on cards, to make it easier to use with a finger (without making a mistake).
  • It’s easier to scroll through a long list of attachments on a card without accidentally dragging them with your finger.
  • The user interface makes it clearer how you can slide your view of a board, by swiping.
  • The panning motion, when you swipe left/right, is smoother.
  • Frequently, card history can take more than a few seconds to load if the tablet is slow or the wireless connection is slow: if this happens, the user sees an indication that the system is fetching the history.
  • Particularly on tablets, it’s easier to scroll down through long card details.
  • We have added a subtle animation on drop-down dialogs (e.g. for Workflow, Chat, Tags, etc.) to help people understand how these work.

Bugs fixed:

  • On iPad, it’s easier to edit text: the cursor shows correctly when you press and hold your finger, bringing up the “magnifying glass” that lets you move the cursor to a specific character.
  • The “hint text” shown on text boxes, e.g. “Enter the card’s description…” won’t get included when you copy/paste from the tablet’s clipboard.
  • A one-second delay in showing the list of available colors, for setting the color of a card, has been eliminated. (Yes, we care about one second delays…)
  • A one-second delay in showing the Tab Overflow button — the button that appears to the right-edge of all your open project tabs when there are too many tabs to display — has been fixed.
  • It was difficult to select a name from the list of auto-completed suggestions presented to you when you want to add someone to a project’s team. That’s been fixed.
  • A bug related to selecting the colors at the bottom of the list of available colors has been fixed.
  • If you tried to change the curve of a line on a Whiteboard or canvas, a bug that caused shadows to show up has been fixed.
  • A bug related to how the text box toolbar was displaying (the buttons for this were showing up in an untidy way if there wasn’t enough space) has been fixed.
  • On canvases, the thumbnail images of some files were showing up stretched when viewed in Safari, although they were fine when viewed using the Chrome browser; this has been fixed.
  • Also on canvases, it’s easier to swipe across the canvas without moving stuff accidentally.
  • When you are using an iPad in portrait mode (i.e. holding it vertically), card details show up properly centered.

What remains:

A ton of work on Android, unfortunately… Android tablets vary so much in terms of processor capability that even the same browser, e.g. Chrome, can behave very differently on different Android tablets & even tablets from the same manufacturer.

Some Android tablets will work better, as a result of all this work we have done, but we can’t yet guarantee that all of them will work perfectly.

There’s a similar, albeit smaller, challenge with Windows Surface machines

Windows laptops and desktops generally work fine, and so do “convertibles” (i.e. dual-screen machines where you can use the mouse or touch the screen), but Windows Surface is still causing some issues because of weirdness within Internet Explorer.

 

 

 

Box vs. Google: what’s different, if you are a Kerika user?

Technology, Usability,

We got an email this morning from a user that we decided to answer here, because the topic is relevant to many of our old users…

We are wondering what the differences between Box vs Google are going to be. Also, if we move over to a Kerika+Box account, will we have to rebuild what we have set up in Kerika+Google?

To answer the first question: the Kerika user interface is the same, whether you use Kerika+Box or Kerika+Google.

And, we fully intend to keep the user interface the same across these two cloud storage platforms — and any others that we might support in the future.

That said, the Kerika user experience, which is more than just the user interface, is a little different due to the quirks of Box vs. Google.

For example, Box makes it really easy to sign up as a new user, and keep your old email account.  You can do that with Google, too, but it’s a lot more cumbersome.

Box also works really well with Microsoft Office files: Box doesn’t try to convert your files into it’s own proprietary format, i.e. it doesn’t have its version of Google Docs, so if you like working with Microsoft Office, Kerika+Box is probably the better choice.

(Note: it’s possible to use Kerika+Google and not have your files converted to Google Docs, by setting a user preference, but that kind of misses the point of using Kerika+Google in the first place…)

If you like to view and edit your files right in the browser, then Kerika+Google is the better choice because Google Docs is getting better all the time.

For both Kerika+Google and Kerika+Box, we try to make sure all your Kerika-related files are neatly stored within your own cloud platform, but that’s a little better on Kerika+Google than with Kerika+Box:

Google allows Kerika to create as many nested folders as we need, which means that you only see a top-level folder called “Kerika.com” when you view your Google Drive, and all your projects, across all the accounts you work with, are all stored inside here.

Box doesn’t allow us to create nested folders in the same way, so you will see a lot more top-level folders in your Box account as your Kerika collaboration network grows.

So, the same user interface for both Kerika+Google and Kerika+Box, but a slightly different user experience with pros and cons for both Google and Box.

And the user interface will remain the same in the future: we have no intention of adding features that will only work with Google or Box — only features that will work well with both.

Now, for the second question: if you create a new Kerika+Box account, you will need to create new projects in this account because it is not connected in any way to your Kerika+Google account.

This may be a bummer for some of our old users who have a lot of projects built up using their Kerika+Google accounts, and now want to switch over to using Kerika+Box.

The reason this limitation exists is that the underlying cloud platforms are completely different, and come from two companies that are competing with each other rather than collaborating in any way.

This makes is impossible for us to move content from a Kerika+Google account over to a new Kerika+Box account, even if they are owned by the same user, since even if we tried to move over all the cards, boards and canvases, we wouldn’t be able to automatically move over any related files.

Sorry about that 🙁

Partial searches just got easier in Kerika

Technology, Usability,

Thanks to feedback from users at Washington State’s Department of Fish and Wildlife (hat-tip to Ryan Koval & team!) we improved our Search feature to make it easier to do wild-card searches.

Wildcard searches let you easily find anything, anywhere in Kerika, by just typing in a little bit of text — as little as a single character — and get back results that match on that text.

(Of course, typing in just a single character will return too many results to be useful… 🙂 )

In general, there are two ways to do partial searches:

  • By implementing wildcards in the query that the Kerika user interface delivers to the Solr search engine that we have implemented.
  • By using a NGram Filter or an EdgeNGram filter.

Using filters could result in a huge increase in disk space utilization, and a significant drop in performance, so we opted for the wildcard approach instead.

To implement the wildcard query, we manipulate two variables in Solr: PARTIAL_MATCH_BOOST and EXACT_MATCH_BOOST.

  •  If you search with just one keyword, we show you the exact matches first, and then partial matches: we use PARTIAL_MATCH_BOOST and don’t use EXACT_MATCH_BOOST.
  • If you search with multiple keywords, we show you the results that match across all keywords first, using EXACT_MATCH_BOOST, and don’t use PARTIAL_MATCH_BOOST.

There are more ways of fine-tuning search, of course, but for now we seem to have made enough of an improvement to keep our users happy!

Why we are integrating with Box, Part 9: Final QA

Government, Kerika, Usability, , ,

(The ninth in a series of blog posts on why we are adding integration with Box, as an alternative to our old integration with Google Drive.)

We have been doing internal testing (“eating our own dogfood”) of Kerika+Box for the past three weeks, and the results have been much better than we expected!

We have found very few bugs so far, which is great — it’s feels like a huge vindication of our decision to invest several Sprints in improving our internal QA processes, clearing the backlog of old bugs, and generally improving our software development processes with code reviews across the board, for even the smallest changes.

In other words, we didn’t move fast and break things: we moved slowly and broke nothing. Which makes sense when you have paying customers who rely upon your product to run their businesses…

Since Kerika makes it really easy to have multiple backlogs in a single account, we put all the OAuth and infrastructure work in a separate backlog, allowing a part of the team to concentrate on that work somewhat independently of other, more routine work like bug fixes and minor usability updates.

And, as before, put every feature in a separate git branch, making it easy to merge code as individual features get done.

Here’s what our Box QA board looks like, right now:

Box QA board
Box QA board

The user interface for Kerika+Box is essentially the same as for Kerika+Google, with a few quirks:

Box requires more frequent logins: Google provided us with relatively long-lived refresh tokens, so a user could close a Kerika browser tab and reopen it a day later and log right back in.

With Box, you are going to see a login screen much more often, along with a screen asking you to re-authorize Kerika as a third-party app that can access your Box account.

This is kind of irritating, but apparently unavoidable: from what we have found on Stack Overflow, Bug views this as a feature rather than a bug.

The other, really big difference is that files are edited offline rather than in the browser itself: when you click on the Edit button, you will end up downloading a local copy of the file, using Microsoft Office for example, and then when you do a Save of that file, your latest changes are uploaded automatically to the cloud.

Here’s what you see when you open a file attached to a card on a Kerika board, when you use Kerika+Box:

Example of opening a file within Box
Example of opening a file within Box

This works great most of the time, except when two people are making changes simultaneously: in that situation, Google’s in-browser editing seems a lot more convenient.

On the other hand, downloading local copies of files means that you get the full power of Microsoft Office, and we know that’s very important for some of our users, e.g. consultants dealing with complicated RFPs or government users dealing with official documents.

Performance also seems a little less than Google Drive, although we would stress that this is highly variable: while Google Drive files generally open within 1-3 seconds in a new browser tab, they can take much longer if Google’s servers are slow.

Overall, we are very pleased with Kerika+Box: we are planning to do all of our new development with this new platform, to continue eating our delicious dogfood 😉

The full series:

Consider killing some of your bright ideas

Technology, Usability

Something that we have learned in the course of making Kerika the best designed tool for work management: don’t rush to implement all of your bright ideas!

When we observe a usability problem, we tend to get riled up rather quickly because we take such pride in our work.

The result is a bunch of really good ideas about how to fix the problem.

And to improve the fix.

And to make the fix even better.

(You can probably see where this is going…)

It’s really easy to over-fix a usability problem, by applying too many fixes, too fast.

Here’s another approach you can try:

  • Collect all your bright ideas.
  • Sort them, so you have only really good ideas.
  • Now, implement the smallest change that you think will fix the problem.
  • And then, eat your dogfood: use the improved product for a week at least, and see if the small change was sufficient.

We have found this is a good remedy to the more common problem of over-designing a solution: rather than build an unnecessarily complex change, or one that creates its own usability problem — often by making a subtle change in the UI metaphors that the user has already learned by mastering other parts of the product.

More fonts for Whiteboards

Technology, Usability

We have expanded the selection of fonts that are available for Whiteboards and canvases:

New fonts
New fonts

The list of available fonts now includes:

  • Arial
  • Armata
  • Audiowide
  • Calligraffiti Regular
  • Cinzel
  • Dancing Script
  • Indie Flower
  • Josefin Sans
  • Kaushan Script
  • Lato
  • Lobster
  • Montserrat
  • Nothing you could do
  • Oswald
  • Pacifico
  • Permanent Marker
  • Pinyon Script
  • Raleway
  • Rock Salt
  • Shadows into light
  • Times New Roman
  • Verdana

 

Kerika looks different: horizontal project tabs

Usability

Our latest release makes Kerika’s user interface look even cleaner and easier to use: we have switched to horizontal tabs to hold all your open projects. (The old version had vertical tabs, running along the left side of the application.)

This makes for more efficient use of space, and provides a user experience that’s more familiar to browser users: the project tabs work like your browser tabs @ndash; you can close each one individually, and drag them across the screen to rearrange them.

It also makes it easier to use Kerika on a tablet: the new horizontal tabs provides a better use of screen real estate.

Task summary emails got a little smarter

Usability,

One cool feature of Kerika is that you can get a 6AM email @ndash; local time, no matter where you are @ndash; that summarizes all the tasks that are overdue for you, due today, and due tomorrow.

And, if you are a Project Leader on any team, your task summary email can also include all the items that are overdue, due today and due tomorrow across the entire team @ndash; even if you are not assigned to those cards. (It’s an easy way for Project Leaders to plan their day.)

Now, these emails got a little smarter: if you move a project to Trash that still has outstanding due dates on cards, these are no longer included in your task summary email.