We have a new (five-minute) video that gives a fast overview of Kerika’s many capabilities:
Let us know what you think!
We have a new (five-minute) video that gives a fast overview of Kerika’s many capabilities:
Let us know what you think!
We have a complete (one-hour long) video of the tutorial presented by Arun Kumar, CEO of Kerika, at the recent Lean Transformation Conference on the subject of Kanban vs Scrum: what’s the difference, and which should you use?
(The slides for this talk, and more, can be found on Slideshare.)
Forming a team 00:01:32
The Product Owner 00:02:01
The Scrum Master 00:02:55
The Scrum Team 00:03:55
Pulling Work 00:04:04
The Product Backlog 00:05:45
Scrum Stories 00:06:25
Writing a good Story 00:07:35
From Epics to Stories 00:10:25
From Stories to Tasks 00:11:13
Estimating with Story Points 00:13:04
Organizing a Sprint 00:15:00
How long is a Sprint? 00:19:15
Sprints in theory 00:20:32
Sprints in real-life 00:20:53
Daily Standups 00:23:25
Burndown Charts 00:24:13
Team Velocity 00:25:35
Best Practices for Getting Scrum Right 00:28:00
The Nuclear Option 00:30:57
Where does Scrum work best? 00:32:02
Scrum in Government 00:33:25
Where does Kanban work best? 00:35:43
Collaboration Networks 00:37:25
Paper doesn’t scale 00:38:30
Using Kerika for Personal Kanban 00:39:50
Using Kerika for Team Kanban 00:40:24
Using Kerika in the Public Sector 00:40:37
Using Kerika for Scrum Projects 00:40:54
Capturing stories as “virtual sticky notes” 00:41:20
Question: how do you deal with poor performers on the team? 00:49:15
Question: in Scrum, are units of measure like lines of code still applicable? 00:50:08
Question: how do you measure individual performance? 00:51:03
Question: how do you handle poor performers within a team? 00:52:25
Question: when do you use the Nuclear Option? 00:54:20
Question: how do you estimate stories? 00:55:54
Photo credits: Abdul-Rasul Kassamali, Jama Abdirahman.
Traditionally, in a Kanban or Scrum board the priority is denoted by the position of the card within a column: cards that are higher priority are placed higher within a column, and the card at the top of the column is the highest priority at that stage of the workflow.
For example, in this view of a board the highest priority item for Planning & Design is the card on top of that column:
This method has the advantage of simplicity and clarity: there is no ambiguity about what is the most important work item at any stage of the workflow.
The disadvantage of this method is that as many cards start to move across the board, especially on boards where the workflow is complex (i.e. the board has many columns), it becomes harder to track all the cards that are especially important.
In other words: the simple method doesn’t scale well, and our goal with Kerika is to provide the simplest user interface on top of the most capable work management system, so we realized we needed to do something more.
With our latest version, Kerika makes it easier to explicitly tag each card with a priority of Normal, High or Critical:
Along with assigning tags to a card, you can now set the priority of the card as well: by default all cards are Normal, but they can alternatively be flagged as High Priority or Critical.
We have also extended the Highlights function for Task Boards and Scrum Boards to make it easy to quickly see all the High Priority and Critical cards on a crowded board:
When you are looking at a board, the High Priority and Critical cards are also highlighted with small stars: a solid red star for Critical, and a hollow red star for High Priority:
The Normal Priority cards don’t have any star; we didn’t want to crowd the design which would have made it harder to spot the more important High Priority and Critical cards at a glance.
And, finally, we have enhanced the What Needs Attention View to include columns for the High Priority and Critical cards across all the boards where you are a Board Admin, or where you have been assigned the card as a Team Member:
We have made it easier for teams to manage multiple Due Dates within the same project, especially when a single work item (as represented by a Task Board or Scrum Board card) contains many different sub-tasks, each of which could have a different Due Date.
Where a card has multiple tasks, each with different Due Dates, the range of dates is shown on cards to make it easier to understand the “time footprint” of the work item as a whole.
Here’s an example of a card with two open/remaining tasks, one of which is due today and the other tomorrow:
When viewed on a Task Board or Scrum Board, Kerika will show the range of dates involved for this card:
This provides better context, better usability for users who work with due dates: at a glance you can see the overall “time footprint” of a work item that involves several sub-tasks.
The What’s Assigned to Me and What’s Due Views are now smarter about handling multiple due dates for the same card: if just one task within a card is overdue, even though the card as a whole isn’t yet overdue, this is shown in the Overdue column in these Views.
Your 6AM summary email (which you can turn on optionally) now lists the due dates on individual tasks within cards, as these become overdue or due this week or next week.
With our latest version, a task within a card (on a Task Board or Scrum Board) can now be assigned to multiple people, just like the card itself.
This makes it easier to handle more complex work items that contain a large number of tasks, each of which may require more than one person to handle.
To make this work, we have also updated the What’s Assigned to Me and What’s Due Views to make sure everyone who is assigned to a task, where tasks have multiple people responsible for them, sees this clearly.
This option lets you quickly spot all the cards on a board that are overdue, and it does so in a smart way:
This smart highlight makes sure that you are aware of everything that’s overdue, even it is just one task that’s buried within a card on a large board.
Here’s what the highlighted board looks like:
All Kerika users have the option of getting an email sent to them at 6AM everyday, in their local time, that summarizes all the cards that are overdue, due this week, and due next week.
(Actually, we have two options for this email: you can get these cards summarized by due date, or by board. Or both.)
This is turned on by default for new users but you can change your preferences at https://kerika.com/preferences.
We have improved this email to include Tasks as well as cards.
This required some smarts in the code to handle scenarios where a Task’s Due Date is different from the Card’s Due Date, but we managed to do this nicely.
What would your company look like if working mothers were a central feature of your organizational design, not a bug to be patched?
It will come as no surprise to our users that the Kerika team uses the software for every aspect of the company’s internal operations, including, of course, our product development.
(There really isn’t anything better on the market for planning and executing product roadmaps — we know, because we have checked and made sure we are better than everybody :-))
We are sometimes asked about our own internal workflow: how we plan releases and manage our Sprints, and in particular how we have gone without using regular old email for over 4 years now!
Well, here’s a glimpse at our internal workflow:
We work in two-week long Sprints; we have found two weeks to be the ideal Sprint length since it provides enough time to produce something — at least some usable part of a new feature — while not being so long that we forget we are supposed to be working as a Scrum team.
Whenever we plan a new Sprint, we are always also looking forward as well: hence the columns titled “Sprint +1” (i.e. the Sprint that will come after the current Sprint), “Sprint +2” (the Sprint that will come after the next Sprint), etc.
This gives a view into the next several weeks of our product roadmap which makes sure we don’t approach any single work item with tunnel vision.
Now you might notice that “Sprint +3” in the list above is way larger than “Sprint +1” or “Sprint +2”: that doesn’t mean that we expect a sudden spurt in productivity (i.e. increase in team velocity) in 4 weeks time. It just means that as we go further out in our planning there is more uncertainty about priorities and so the Sprints that are well into the future are not well defined — and that’s perfectly OK.
Within each Sprint we have a fairly conventional flow: Planning, Development and QA. The QA step actually consists of three separate stages:
This can be a little scary or frustrating at times: if there was a bad release to our staging environment, it can bring every project and board to a screeching halt. But, from our perspective, that’s the whole point: make it everyone’s business to ensure that we produce high-quality code, and make it everyone’s priority to fix any problems that come up.
This model of living on the bleeding edge of our product gives us a really good incentive to write good quality code!
Very occasionally something will get rejected at the Show & Tell stage, in which case the card gets moved back to Planning or Development and flagged as “Needs Rework”. It’s more common for work to get rejected at the Code Review phase, not because it is buggy, but because it might not meet our internal coding standards.
Once a feature or bug fix has passed Show & Tell, it is ready for Deployment to Production.
We have a continuous integration process for handling code changes — pulling them from our internal git code repository — but we don’t do continuous deployment. Instead we prefer to deploy on the last day of each 2-week Sprint. We usually time this for Friday morning, Indian Standard Time, so that our developers in India can take one final look at the system working in production.
We have an unusually strong emphasis within the team on creating documentation at the same time as we write code. Many small companies skip documentation because they think it will slow them down.
In our own (sometimes bitter) experience, skipping documentation is false savings: if there are problems to be fixed later, or even if a feature simply has to be extended in the future, it’s very hard for even the original developer to recall the logic that she used to write the code in a particular way.
What’s important to note, however, is that we don’t have very big documents: most documents are less than a page long, because they refer to very specific work items. But we have thousands of these small documents, since every feature we have ever produced, and every bug we have fixed, has been documented.
And thanks to Kerika’s very cool integration with Google Docs (we use Kerika+Google), managing these thousands of documents is very easy: just open the relevant card for a specific feature or bug fix and you will find all the relevant documents as well:
For new features we always have a short Planning Document that identifies any existing modules that will be affected and provides an outline of the new code that will be written. Here’s an example:
There may be other documents created, depending upon the complexity of the new feature, but even the smallest new feature will have at least one planning-related document that’s written before the code is written.
For bug fixes, we have a Repro, Cause & Fix document that methodically analyzes the cause of a bug:
The most important section of this document is the Introduced Since piece, where we trace the origin of the bug back to its source, to understand what new feature or bug fix we were originally working on that resulted in this new bug appearing.
This methodical root cause analysis, which we do for even the most minor bugs, helps us identify patterns in our code writing that we need to improve. Sometimes it can even point to bugs that we haven’t discovered yet: the root cause analysis may identify an assumption that we have applied in other places, all of which need to be looked at to make sure there aren’t other variations of the same bug that haven’t been identified yet.
After the bug has been fixed, the Repro, Cause & Fix document is updated to reference the git branches where the code fix can be found. This completes the circle of careful analysis, careful execution, and methodical review that we strive to adopt (and improve continuously).
We stopped using regular email towards the end of 2013. There was never any formal decision to renounce email; instead there was a formal decision to “eat our own dogfood” in a very serious way.
And as we started to build our entire company using our own product, we found that using Kerika is so much better than using email that there really wasn’t any need for email any more.
So people simply started drifting away from email. There was no explicit decision or formal movement to do so, people just realized, on their own, that email is an exceptionally poor way of managing work within a distributed team.
Considering the size of our team — and entire company, for that matter — you may be surprised by the degree of formalism we have adopted, and the heavy emphasis on analysis and documentation.
We spend at least as much time on analysis and documentation as we do on “pure coding”, and if we add in the Code Reviews and other elements of formal QA, the actual coding time is a relatively small portion of our total expenditure.
But trying to skimp on analysis and documentation really doesn’t pay off, in our experience: if you are building a company and product for the long-run, as we very assuredly are, you need to build it right, not just fast.
One final (?) bit of restyling, to make all of Kerika consistent with our new look-and-feel, has been updating the Board Settings dialogs.
The functionality is essentially the same, but the appearance is cleaner, lighter and more in keeping with the Material Design standards we have (mostly) adopted.
(We say “mostly”, because there are some elements of Material Design that we find unattractive. For example, for the on/off toggle switches we prefer the iOS style buttons.)
The Column Settings dialog has also been restyled, and looks nicer and cleaner. The example above shows a board that uses Work-In-Progress Limits.
And the same with Tag Settings: we have a restyled color picker, and better messages for warnings when tag names or colors might clash.