Setting SMART Goals for your Team

Annual reviews are often one of those things we do as a box ticking excercise. It’s dull, time consuming and there are often more interesting geeky projects you’d rather be working on.

Words like SMART buzz around our brains for a few weeks and then are promptly forgotten (much like the goals) until the same time the following year when each goal is ticket off as “Done” or “No Longer Relevant”.

Surely there’s a better way?

Let’s look at what SMART stands for…

  • Specific
  • Measurable
  • Attainable
  • Relevant
  • Time Constrained

Your business may have different words but the jist is the same.

I want you to think about these words differently. Instead of writing goals for someone to achieve I want to think about User Stories. It’s reasonable to demand that any PO writing new features for the backlog should create them so they are Specific, have good Acceptance Criteria, be feasible to implement, be a valuable addition to the software, and should fit into a single Sprint.

In other words SMART is just another way of setting detailed and unambiguous instructions!

So now we know that SMART is simply a way of writing clearly let’s look at what goals you should set.

What do you expect your Team Member to be doing for the upcoming year?

This may sound like an obvious question but in my opinion annual goals shouldn’t all be about Continuous Personal Development or an arbitrary “I’d like to lean that” because these are the first things which will be abandoned when you have a tough day. Instead look at what your department goals are and propagate these through to your team.

If you have a major release coming up then set that as one of the goals. If you need to analyse system performance or memory usage then write it down. What you will find is instead of irrelevant targets which will be abandoned in favour of more pressing work your team will suddenly become accountable for getting the releases out to customers. Not only that, but they will see that their day to day tasks are being used to measure performance instead of the “Nice to Haves” which were abandoned as soon as the year hit a rough patch.

You will quickly find that most developers will much rather have a goal of “Create Offline Sync Mechanism as specified in Feature 123 before the end of January” than something vague like “Improve the Support mechanism”. For one thing there’s a lost less ambiguity as to whether it’s actually been achieved! Remember, less ambiguity means fewer awkward conversations when you come to assess goals, that has to be a good thing!

In conclusion, setting clear (or SMART) goals for your team which actually reflect the work they’re going to be doing day to day is a great way of getting investment in your department’s objectives and helping making those annual review forms much more relevant. Learning goals are good, but they shouldn’t be the core of a Team Member’s assessment.

Restructuring your Sprint to Produce Finished Software

If your company is anything like many of the teams I’ve worked with your Sprints are a planning tool used to break down monolithic projects into smaller pieces to track progress.

In the real world big releases often pressure development teams to adopt more established project management techniques to hit deadlines. A PM will nominate a certain number of weeks for development (hopefully based on estimates your developers have provided) and then subsequent time for testing, bug fixing and UAT. The Development Manager will then allocate time into those Sprints.

But wait a minute? Doesn’t Scrum team us that we should be able to produce full working software at the end of each Sprint? If that’s the case then why are we saving all of our testing and bug fixing until the end!? It feels to me as though we’re running Sprints but ignoring the line of the Scrum book which talks about finishing a Sprint with deliverable software.

In Rolling Rocks Downhill Clarke Ching calls this GETS Software (Good Enough To Ship), it’s a term I like. In his book the team would build feature after feature however at the end of each iteration they ensured the product was GETS. That meant that if something took longer than expected or their budget was cut the team would always be able to fall back on the last version.

In a typical PM managed project I envisage features a development phase, when new bugs are carefully and painstakingly introduced. Then a testing and bug fixing phase, where they are removed.

waterfall_bug_flow

If however you commit less work to your Sprint, let’s say half the amount then your developer can spend the second week refining their work, working alongside the QA, designing upcoming features, and removing any bugs which are found.

This will obviously reduce your Sprint Velocity, however it will mean that whatever work is completed is completed, reasonably and as Clarke puts it GETS. However without the need for long and laborious bug fixing phases this time can often be reclaimed.

agile_bug_fixing

This approach is game changing for a number of reasons. Firstly your quality isn’t compromised, instead of a quality decline and then improvement your software stays at production quality. Second, should your customer, Product Owner, or business priorities change you can update your plans (maybe even delivering early). Surely that’s what we mean by Agile!?

Many thanks to FooPlot for the brilliant site I used to create these graphs and Jing for the screenshotting and labeling software.

The Phoenix Project Book Review

I recently read The Phoenix Project, the definitive and often referenced DevOps Business Novel by Gene Kim, Kevin Behr, and George Spafford.

I have to admit I’ve been putting off reading this book, perhaps I had some misgivings about replacing Scrum techniques with the new craze of DevOps. Having decided that I was going to invest my time I was tested once again when I realised that Bill, the book’s main protagonist is an infrastructure guy… I’m a Development Manager, I want to know what DevOps can do for do for me not what I can do for the other guys!

That however was the last time I paused before devouring the remaining 370 pages.

Bill’s first few days after his promotion are littered with disasters. He has a project to deliver, infrastructure problems to resolve, and political ambushes to endure. In other words, he’s in the situation we’ve all experienced when teams aren’t communicating and colleagues are so stacked up with their own projects and priorities that they simply can’t assist each other.

With the timely arrival of Eric, the new potential board member Bill slowly equips himself with the tools he needs to resolve his infrastructure headaches and get the Phoenix Project back on track. Eric, acting as a kind of DevOps Yoda helps Bill gain an understanding of the four different types of work, the Theory of Constraints, Systems Thinking and see the value of Automated Deployments.

There’s a nice appendix at the end which helps consolidate the ideas and explains some of the ideas away from the story. There are also some mind blowing statistics about how some of the big web companies such as Amazon, Google, and Netflix.

So would I recommend this book to others? Absolutely! In fact I have, repeatedly to friends and colleagues! Whether you’re a developer, infrastructure guru or IT manager this book will introduce you to several new ways of thinking about workload management and IT processes.

Playing with Microsoft Cognitive Services

It’s time for a little fun – inspired by Martin Kearn‘s talk at DDDNorth I fired up the Microsoft Cognitive Services Website, signed up and got myself a key for the emotion API. It didn’t take me long to get up and running!

I tried briefly using the SDK library but found some trouble with strongly typed names, deciding the abandon that approach I used the method Martin recommends on his blog and simply downloaded the json myself and parsed it.

Here’s my code:

        var _apiUrl = @"https://api.projectoxford.ai/emotion/v1.0/recognize";

        using (var httpClient = new HttpClient())
        {
          httpClient.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", _apiKey);
          httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/octet-stream"));

          //setup data object
          HttpContent content = new StreamContent(new MemoryStream(File.ReadAllBytes(filename)));
          content.Headers.ContentType = new MediaTypeWithQualityHeaderValue("application/octet-stream");

          //make request
          var response = await httpClient.PostAsync(_apiUrl, content);

          //read response and write to view
          var responseContent = response.Content.ReadAsStringAsync().Result;
          var objResponse = JsonConvert.DeserializeObject<RootObject[]>(responseContent);

          var image = Image.FromFile(filename);
          using (var gfx = Graphics.FromImage(image))
          {
            foreach (var face in objResponse)
            {
              gfx.DrawRectangle(new Pen(Color.Red, 5),
                new Rectangle(new Point(face.faceRectangle.left, face.faceRectangle.top),
                  new Size(face.faceRectangle.width, face.faceRectangle.height)));

              var text = this.GetText(face.scores);

              gfx.DrawString(text, new Font(FontFamily.GenericSerif, 64), new SolidBrush(Color.Red),
                face.faceRectangle.left + 24,
                face.faceRectangle.height + face.faceRectangle.top);
            }
          }
          this.pictureBox1.Image = image;
        }

I’m very impressed with how easy it is (in fact most of it’s being used to update the picture box in my little Winforms app!).

What do you think? Do I look about 65% surprised?

emotion_screenshot

DDDNorth 2016

I was very excited when I saw the announcement of DDDNorth earlier this year. I’ve attended the conference several times before and to see it was once again in Leeds really gave me no excuse not to attend!

Despite having a rather late night the previous evening I was one of the first there, in fact I think I accidentally tailgated a speaker inside and sat quietly in the corner until the masses arrived.

For those of you who don’t know the DDD events are free, one day conferences focused at .NET developers. They’re held around the country and have a very high standard of speakers. DDDNorth is our annual event and usually circulates between the Universities of Leeds, Sunderland and Bradford.

The first session I attended was “Machine Learning for Muggles” by Martin Kearn and it was one of the best geeky talks I have ever attended.

Martin demonstrated how to use the Azure Machine Learning API to upload your own data for analysis. He then took a photo of the audience and used facial recognition and text analysis to ask questions like “show me the happiest person”. Before today I’d always assumed machine learning was only for the likes of Google, before the first coffee break I was already wondering whether I could use the APIs in our own products.

The second session I attended was “10 More Things You Need to do to Succeed as a Tech Lead” by Joel Hammond-Turner. I’d attended one of his talks before (entitled 10 Things You Need to do to Succeed as a Tech Lead) and with my recent change in role I felt it was a wise choice session.

I was right. Joel gave us a good list. It contained tips on requirements, instrumentation, and team training. I was particularly impressed by his thoughts on managing and measuring technical debt!

The last session of the morning was “You read The Phoenix Project and you loved it! Now What?” by Matteo Emili. Having recently bought and demolished TPP while on holiday this was the session I was perhaps most excited about. Matteo argued for pragmatism, he told us that in order to sell process changes the value must be determined. He quoted the common phrase “you can’t manage what you can’t measure” and discussed in depth how you should use the Build-Measure-Learn. There were even a few tips and ticks towards the end to help us get our automation deployments going!

It was lunchtime, which meant sandwiches and GROC talks (I have always been curious to know what that stands for).

I arrived in time to see a few interesting mini-talks. The first was on using the C# interactive window in Visual Studio, the second was around ARM templates for Azure, and the final one was entitled “What’s the Point of Microsoft?” and was a tongue in cheek presentation about how the big tech players compete in today’s software and hardware world.

I’d love to continue, I’d love to tell you about the Microsoft BOT API talks I had lined up for the afternoon. Alas it was not to be, it was around this time that the office called to tell me that several hundred members were having issues with their accounts. No rest for the wicked!

I’d like to take the time to thank the DDDNorth team for putting together yet another fantastic event. The speakers this year were superb and if I get the chance I fully intend to catch the sessions I missed elsewhere in the country at a later date. See you next year!

Rolling Rocks Downhill Book Review

I read Clarke Ching‘s book Rolling Rocks Downhill a while ago and I picked it up again recently while on holiday. I’d enjoyed it the first time, going back over the story a second time with a little more leadership experience I was amazed just how many valuable lessons Clarke has managed to cram in there!


The book is a Business Novel and follows Steven, the Development Manager at Wyxcomb Financials who discovers that a competing company has stolen their idea and is determined to beat them to market. Their project on the other hand is behind and likely to slip even further. With their company’s future at stake Steven must develop a new approach to development to save the day.

What follows is a story of a team discovering Agile ideas and practices for themselves.  Not because they have a guru preaching at them, but because they’re trying to solve real business problems. I couldn’t help chuckling at some of the discussions Steven has with his mother, the Product Sponsor, and even the Cafeteria Manager as he learns about Iterative Releases, Product Backlogs, Continuous Testing and the Theory of Constraints.

After all can you really understand the advantages of building a small number of features in an iterative manner if you’ve not heard about the French Fry Revolution!?

An easy read and a great book to really reinforce some of the ideas of scrum you already know with real world examples. Recommended to anyone!

Is Proper Project Management the Waterfall We’re All Afraid Of?

I recently watched a Pluralsight course on Project Management for the Software Engineer. My role has changed recently and I’m finding myself far more involved in planning the team’s big picture. I hoped with a few more ideas and skills under my belt I’d stand more chance of rising to the challenge when things get tough.

Having watched the video (very good by the way, I’d highly recommend it) I came away with an uneasy feeling that this “Project Management” stuff was simply Waterfall under another guise. As developers we’ve been so bombarded over the last few years with the message that Waterfall is antiquated and Agile is the new methodology and that all notion of long term planning and detailed requirement documents must be stamped out.

Needless to say that when I watched the video explaining the importance of a proper project plan and detailed specifications I was rather taken aback.

Surely we’re not preaching a return to the old days of strict deadlines and work planned out months and months in advance?

It is at this point that I have to raise my major frustration with Agile and Scrum in particular. Everything I’ve read and every speaker I’ve listened to advocates a prioritised backlog of work which the team will work through to deliver maximum benefit to the business.  This is great for a startup, or a team developing a solution where they are continuously refining a project to deliver more and more value.

In my experience however the business process is rarely so clear cut. For example, I have a deadline looming, several customers have paid for dozens of new features to be included in our application and the sales team have committed to a UAT delivery date of the end of June. Suddenly I’m not working to a prioritised backlog, I’m working to a project deadline and failure to meet it could have serious repercussions!

So how do we combine these two approaches? How can I maintain the ownership and agile nature of a scrum team while carrying out the long term project plan necessary to ensure a successful delivery? Is it possible or are the two mutually exclusive?

Let’s look for a moment at what the Project Management approach promises us

  • A clear set of deliverables agreed by the client
  • A clear list of delivery dates for stakeholders and other teams in the business
  • Easier control by planning work up front allowing us to track progress and spot issues arising

Is there a way we can keep these benefits without sacrificing the agile nature of scrum?

A Clear Set of Deliverable agreed by the Client

Let’s take this one one first, Agile does not mean wishy-washy requirements, it means breaking down big visions into manageable and deliverable chunks. While a client may envisage a huge monolithic project it is the job of the project team to break this down into small, simple user stories which can be delivered in manageable pieces.

Where an analyst may claim that a multi-document specification contains every use case and scenario they system may encounter I’d be willing to bet significant money that they’re wrong. Furthermore, by the time you deliver this enormous project the business value for it may have waned dramatically (I’ve seen this happen myself). It is undeniably better to break your huge requirements down into components which can be delivered for continuous feedback as you go.

A Clear List of Delivery Dates

Assuming you are working in a scrum team the agile process does not obscure delivery dates, in fact it embraces them. Rather than setting an arbitrary deadline months and months in advance and gearing the resource and financial plans towards it continuous and iterative releases increase the reliability of hitting deadlines, after all – it’s less likely you fall significantly behind over a two week period than a two month one!

Use your sprint end dates as your deadlines, deliver frequently into a sandpit environment so the client can see your progress and begin testing as early as possible. Big deadlines are a lot less stressful when you’re on the nth iteration!

Upfront Planning for Clear Progress Tracking

As a Project Manager you are going to be continuous asked whether a project is on track to meet the business deadlines, I’ve not tried it myself but I’m willing to bet turning around to your client and saying “We don’t have deadlines, we’re agile…” Probably isn’t the best approach.

When we create our backlog we break our features into User Stories, each is estimated and prioritised. At the beginning of each sprint the highest priority items are selected to be worked on. From a project management perspective is that other, “more important” stories may be moved into the sprint in place of your items.

However in a business environment we need to plan releases and deliverables several sprints in advance. as a Project Manager we need to ensure that our work is completed on schedule and not simply pushed back until the 11th hour.

My suggestion here would be create a project plan which covers which sprint each User Story should be completed in, these should be negotiated ahead of time with the Product Owner. At the beginning of the sprint the work which was planned in is moved up to a high priority. On a quiet week the team may have capacity to complete your planned work as well as some of the other tasks, on a busy week your work may not be the most pressing (there may be customer support requests which take precedence for example). However, as with all things it is the Product Owner’s prerogative to decide which tasks will give the most business value yours, or the other challengers.

What this process allows is for you to plan out your control points well ahead of time. If you’re expecting certain tasks to be delivered at the end of sprints 2, 4, 5 and 6 then you can begin monitor these and verify that these targets are being hit. If they’re not then you can explain very clearly why they fell behind whether this was because a task took longer than expected or because a more pressing task came in.

This is the same process we already work in, resources can be reassigned at any time in a normal project. The advantage here is that the Product Owner formally balances the priorities of the business and gives reasons why the project must be allowed to fall behind.

Handling Scope Creep

As developers we’re constantly aware of the pressures of scope creep. A piece of work is designed, estimated and scheduled in. Then, as soon as the client sees it they have another idea and want a further feature to be added. In an agile environment we want to encourage this feedback, ultimately it helps us build software which better suits our customers’ needs.

From a business perspective this feature creep can be deadly. Budgets are drawn up and quotes delivered based on the original feature, if these prove to be inaccurate or underscoped then you are effectively delivering your service for free.

In order to avoid this it’s vital that a formal process for Change Requests is given ahead of time. If a customer feels that this is their one and only chance to refine the product to make it valuable to them then they will push and push everything into the same delivery. If however a formal CR process exists they know they can continue to work with the team and refine as they go. There’s a theme here, the emphasis needs to move away from a single monolithic and towards small, iterative and manageable releases.

In Conclusion

I believe that the two approaches of Project Management and Scrum are not mutually exclusive. In fact I believe both aspects are vital if you want to achieve anything other than a constant aimless meandering of features.

For the two approaches to work well together I feel there are few steps which must be carried out:

  • Break your project into manageable tasks and tentatively assign them to sprints with the agreement of your Product Owner.
  • Measure the progress of your project through it’s lifetime, ensure that if a task is not completed in the given sprint you understand why and stress the urgency to the PO that the ground is made up.
  • Embrace change and allow your customers to refine as the project is developed. Formalise the process and be clear that any change will be re-scoped and budgets will be updated.

I’m going to be attempting this approach in a few weeks for a release to our biggest customer. Hopefully this balanced approach will see us through.