Case SMM-app KUKU.io: the path from sprint 4 months to reasonable planning

the Guys from startup KUKU.io, a popular service for SMM have come a long way from the chaotic planning of sprints, stretched for almost half a year, to a logical task management, Autonomous teams, and finally close in time sprints. Young projects note.

Project Manager Paul shared the story about how I managed to painlessly resolve most problems:




We develop SMM-app KUKU.io since may last year and only now we managed to configure all processes to chaos in the task was minimized, and users were pleased with new functionalities which were requested by us, as often as possible.

When we started out, KUKU.io was able to publish content in 4 social networks: Facebook, Vkontakte, Twitter and Linkedin. Clearly, proper management of social networks-this is great, and the app gradually start to grow into the other features users like to see the division of social networks into channels or projects, social network analysis has become a key factor in the choice (or selection) of service, UTM-tags, link shortening, many images in one post, a new social network (now KUKU.io supports 10), etc. — all had to implement.

In the early days, when I came into the project there was a situation, when everything seems clear, but in fact nothing is clear. What is the project, I realized very quickly, without details, because the product is already in production, and you can poke to see what's what. Besides, the team immediately took care of the cool UX/UI, to work for a few minutes can even people far from social networking.

The team... the Team is great all the guys are professionals in their field: from the unreal developer to marketer and smica. Who does what, is not clear. :) There are some project management and systems: Jira and GanttPRO, in them something is, but it's any idea (story tasks, you need to minimal logic, no nothing).

Get into the documents — is in drive the sea of folders like names something appropriate planned: alpha version, competitor analysis, beta, demo, SPECA version 1.0 and so on. Open header, some sketches and all.

The result is: a working product without understanding how and what it works, who's working on what, who is the product owner who is responsible for what, where the project is going, what goals in the future, which working rules. Planning does not identify what it was, apparently, tried to come to some kind of flexible framework, but threw. In the result, there were a lot of releases, sprints uncovered, giant sprint in 4 months. The work process was such a scheme: virtually any team member created issues in Jira, of course with no descriptions.

Ie climb up to the sprint or backlog, and there is some beard "Modify existing unit" or bug "Not working login — console error #".

Of course, the product in production recently. Bugs of the sea, functional features are not enough, they need to roll out quickly. Plus the payment system is necessary to bind, fire full.

So I started with a simple:

the
    the
  • based on Kanban (your project, so no time-bound).
  • the
  • to determine who is responsible for what, who makes decisions.
  • the
  • Selected relevant tasks.
  • prioritize. the

  • Agreed with QA about the method of describing the bugs in the form of use cases describing the environment.
  • the
  • Finally, programele backlog (took a very long time).
  • Began to describe all through history, in order to reduce the number of bugs.


There are different mechanics, estimation techniques and frameworks that are suitable for outsourcing companies, but quite impossible from their own projects. We began to choose elements from different methodologies and sampling that will take root.
From the Scrum, we took Daily Meetings, which immediately showed sore spots in your workflow and enabled the students to understand what people are working on and to communicate within the team. Unfortunately, in the beginning they took a very long time, sometimes up to an hour. Decided this issue, when the team became more Autonomous: now at the meetings there is no place for discussions of problems, only a quick report of who is making and plans to make.

Then I tried iteration, but it has not produced the desired effect, as the product is live, the team bombed features one-by-one bugs the rod. Not very helpful at first, but we'll get there, slowly but surely.

Retrospective, we did not enter, as there was no special meaning. Planning was done for a month, as faster unlikely would too dynamic project, although now there are problems with timing. Decided that to story points, we arrive late and left everything to her, but the description of logic and use cases that gave quick results: acceptance criteria were clear for all, and reduce the number of bugs.

From XP took a large part of CI (Continuous Integration), accelerated the updates and, again, allowed us to produce higher quality releases, feedback from the client (users' feedback) was taken as the basis for prioritization; all decisions were made by yourself, on your own risk.

By the way, about priorities. It has become one of the most painful processes. Everyone thinks their task is the most important, and fights for it until the end, and I would like to prioritize less "blood".

We used to have a stream of your tasks and feedbacks that we do not know for what to undertake, and rushed everything to please every user. The next stage was the full asynchrony of action: my goal is main. Now, when we debugged a no process and came to understand that to please everyone will not work, we began to intelligently distribute user recommendations and balance between internal tasks and new requests. To our delight, the users ' queries in most cases are very similar, and we can confidently add new features.

Kanban has helped your Board and left him, only added a few columns, based on the needs of CI.

Later, from a Scrum took the story and epics — go to detailed planning. We can say that we come to more detailed planning and short iterations. Now we know that we will have almost a month in advance to 80-90 percent. And can easily make changes.

The next step for us was creating an Autonomous team. All write that the Autonomous team is cool — and it's really cool (have chewed why: more engagement, interest and impact that allows you to call a group of like-minded team, less risk, and misconception) — but the developers, for the most part prefer to be left alone, they say, give us your requirements specification detailed, and we TK everyone and will do, and if it is clear — we are all cool, will do in its sole discretion, and readiness will determine too.

Which in our case led to autonomy:

1) constantly changing and growing product and release — all smelled gunpowder in the roles of other participants and have an idea what and how to succeed in the product.
2) daily rallies — we not only tell that someone does, but try to solve promptly the task, thus the whole team, though vaguely, but he knows about the changes or about the problem (if we understand that the discussion drags on, the other participants release).
3) planning — we know what we are now and where we're headed.
4) spacenet team — Hiking in bar, corporate events, live communication, no pressure.
5) communications — still need to grow in this direction, but now, if someone has a problem, it is not kept in store for a long time, and just say your Fe or hit the bell, have no fear to speak.
All this led to the fact that the guys know about the relationship of their tasks from the partner or from third-party factors and not working in the dark, small schools, and the problems get fixed quickly in the Bud or even Bud :) less fixes and technical debt, as clear medium-term goals.

So, what is the result? First of all, we have reduced the number of bugs: say how, do not undertake (to be honest, not led accounting, it will be interesting to perform), but we have a very good product, and those bugs that do appear, are not critical — some minor flaws mostly due to carelessness (though still there are schools with Meriem and diplom). But our QA (and he's 1) began to live easier, and to delight users releases we have become much more often.

We planned for about a month, then fix, regression, deployment. A total of approximately every 5-6 weeks will realisim update with major features and updates with the bugfix for the receipt of messages from users. Before all our plans were space. Sprint for 3 weeks could drag on for a couple of months.

Striking recent examples: this is the Content Plan for social networking and Team Plan for SMM and marketing agencies and companies, in which not one person involved in promotion of social networks. Last we thought to do a month on the first estimates without understanding how it should be. After the analysis, decomposition, write a small "speck" estimated the scope of task 2 of the month. In fact, the team was vicitra command plan, a lot of parts to it, smm and marketing of buns, annual subscriptions, improved Analytics, social networking, tested it all, did a regression and reliznuli in production for 3 months. Given the fact that we have 3 developer, two were in session and the eviction from the dormitory, parallel with developing the Content Plan, they are interconnected and should meridia without conflict. And it all worked as described. It's really a success!

Another achievement is a huge achievement is less conflict in the team.

Then I would like to come to more frequent releases and to notify users about our next update. The entire road map, I don't think it's so cool to show no interest, all in the palm of your hand and will wait. :)
Article based on information from habrahabr.ru

Комментарии

Популярные сообщения из этого блога

When the basin is small, or it's time to choose VPS server

Performance comparison of hierarchical models, Django and PostgreSQL

From Tomsk to Silicon Valley and Back