Rusty Divine

Live, Love, Learn, Teach

Agile Story Pointing Benchmarks

We use story points to estimate how much effort a given story will take. We have found it reduces optimism inherent in estimating with hours because it encourages the team to use comparisons to other stories instead of imagining how long it will take. When we do estimate with hours, we typically think about the happy-path, and really, that’s OK.

Consider a two-week iteration with 10 stories. Maybe 6 of those stories take the happy-path and are completed pretty much as expected. Two stories are actually a lot easier and are completed faster than expected, but the other two take significantly longer than expected. The problem is, we don’t know which 2 those are in the beginning, so there’s no way using hours to accurately estimate. Instead, if your team is fairly consistent, you can use points to know that in a given iteration you can complete 30 points of stories. A few of those stories turn out harder than you expected, but that’s always the case. Everything evens out in the end, or at least, evens out more consistently in the end.

But, to get this ball rolling your team really needs a good common understanding about how to compare two stories to know how much bigger one is than another. We use the series of sizes like: .5, 1, 2, 3, 5, 8, 13, 20 –> we rarely let a story stay at 13 or 20 without breaking it down further because at that size we’re getting into something we’re not sure someone can complete in one iteration. You can start your team off by choosing a very familiar story that can be your 2-point benchmark, and one that can be your 5-point benchmark. Then, every story you consider can be compared to those two benchmarks and your team can collectively decide where in the range the story fits. Typically even non-developers can point development stories and developers can point non-development stories as long as they can fit it into their mental picture for how much effort a story like that would take.

Our team has experimented with taking it one step further and creating descriptions for each of these stories. This is still experimental and the general feeling is we would need to shorten this list by about half to make it more concise:

.5pt story

· Small bug fixes with no foreseeable risk and small JavaScript tweaks

· Small view updates; no tests affected (spelling; remove field; add label; move field)

· Business meeting that requires less than two hours of prep work

1pt story

· Bug fix with low-to-medium difficulty/risk, but well-understood, may affect a few tests

· Simple well-defined task (new validation; make field read-only when; fix/improve CSS)

· Research task time-boxed at about a day (what if scenario; will this work)

· Business meeting that requires two-to-six hours of prep/follow-up work

2pt story

· Bug of medium difficulty/uncertainty, or several tests affected (unexplained JS errors; AJAX)

· Understood task spanning >1 layers/screens/tables (validation rule server & client side; repetitive but tricky; significant data load script changes)

· Try small prototype (performance improvement; what if scenario)

· Business meeting that requires both significant prep and follow-up work (6-to-12 hours)

3pt story

· Bug fix of medium-high difficulty, significant uncertainty, or many tests affected (concurrency;

· Very simple screen or feature (system functions; nightly jobs action)

· Task spanning multiple layers/screens with one-or-two business rules to modify

· Significant updating of existing documentation (UCP; user manual; tech document; workflow)

· Multi-day research tasks (investigate one-to-two COBOL programs; new framework/tool)

· Business meeting requiring 2-3 meetings or >2 day research/analysis

5pt story

· Bug fix of high-difficulty, high uncertainty, and probable course changes (fix & refactor)

· Design & implement new feature, service, or framework (toast; branch-wide; JS test framework)

· Research & implement performance improvement (batch update via sproc; profiling)

· Documentation branch-wide (style guide; user manual)

· Series of 3-5 business meetings with analysis and design (pink sheet; COBOL workflow)

8pt story

· Implement a new feature that affects most/all of the site (granular security; table logging)

· Refactor a significant amount of code (funding section page, database/code renaming)

· Implement a screen from CICS (estimate adj.)

· Comprehensive documentation (site-wide user guide, technical specs)

· Significant research that will take most of the iteration for one person

13pt story

· Design & Implement an automated process/service (prod>test data move)

· Significant research task that could take all of an iteration for one or two people

20pt story (Consider if this story can be broken down into smaller stories)

· Large research task that could take an entire iteration for two-or-three people

· Very complicated refactoring

· Create and configure a new project solution (n-tier, nugget packages, tests, basic gui)

Code Reviews in Visual Studio 2013

This is the process that I created for our team to do code reviews.

Working on a User Story

After finding the next story in priority order, assign it and the tasks to yourself in TFS and put your name on the printed card and move it over to the Working On section on our task board.

The story will now show up on the My Work tool in VS under Available Work Items (If you haven’t yet customized your Available Work Items query, jump to that post first).

clip_image002 clip_image004

Drag the user story from the Available Work Items to the In Progress Work. Now it will be associated with your change set so that it will be easy to find during a code review. When you check in your changes, this story will automatically be marked as resolved for you.

If your user story has nested bugs or other user stories, add those, too (you do not need to associate tasks). Then, when you check in, the child bugs and stories will also be marked resolved and the bugs will be re-assigned to whomever reported them.

Each night suspend your changes before you leave for the day. This will create a shelf set for you in TFS so that if your computer dies your changes will not be lost. Be aware after you resume a suspended shelf set that shelf set is deleted from TFS, so if you want to keep a shelf set around, actually shelve it.

You can create more than one suspended work sets and each remembers all of your open windows, break points, and other VS context settings, which makes it really easy to jump around between tasks like code reviews, bug fixes, and different work items.

Requesting a Code Review

Before you request a code review, make sure to get latest, merge any changes, and run the tests to make sure they pass.

From the My Work tool under In Progress Work, click the link for Request Review. This will create a shelf set of your work in progress and associated user story. We code review all features prior to checking them in.

If this is your first time requesting a review, you will need to add each team member individually via the drop down list, but the next time you can just select the “Add Recent Reviewers” link. Enter a description if you like for the review and click the Submit Request button. You can see the shelf set this creates by going to File>Source Control>Find>Find Shelf Sets.

The team will receive an email about the request, and it will appear in their My Work tool under Code Reviews>Incoming Requests.

At this point you can undo your changes and do someone else’s code review, or grab the next story that needs to be worked on. You can review the status of your code review request by vising the “My Code Reviews & Requests” list in the Code Reviews section of the My Work tool.

Remember to move the printed card on the task board over to the Code Review section.

Accepting and Completing a Code Review

It’s important for everyone on the team to participate in code reviews because it is good practice to critique others code and learn from it at the same time, it helps improve understanding of the system, and it helps the team so that some members don’t get stuck doing more than their share of reviews.

You can find reviews either in the email list, or better, in the My Work tool in Team Explorer under the Incoming Requests.


1. Suspend your current work so that VS is cleared.

2. Double-click on a code review in the Incoming Requests list.


1. If no one else is marked as Accepted you can accept the review.

a. Generally we only have one team member do the review. You do not need to decline code review requests, they will fall off your list once the initiator closes the review.

2. By clicking on the file name you can see the difference comparison. Within the comparison, you can highlight sections of code, rt-click, and add comments to the developer. You can also check the box on the right to keep track of which files you have completed.

a. If it is a long code review, you can even send comments back before you finish your review so that the developer can start working on them (not shown above).

3. You can add an overall comment on the code review. We sometimes use the format:

* Unit Tests/Coverage Complete?

* User Story COA Met?

* UCP Mockups/Text/Validations Updated?

* Refactoring/Rework Needed?

4. Make sure you always get the shelveset and test out the code in your local browser. Do a little regression testing yourself and make the QA team’s job easier!

If there are any C# changes, make sure to run all of the unit tests. Use Test>Analyze Code Coverage>All Tests to check for code coverage in new code (we try to write tests for any code we create or update).


1. Double-click on a method that is not fully covered.

2. See in red highlight the code that is skipped. Leave a comment on it if there are just a few places missed, or an overall comment on the code review if there are many places missed.

After you are finished reviewing the code select a response from the Send & Finish drop down in the code review:

· Looks Good: go ahead and check this in

· With Comments: minor changes or maybe updating a document like UCP

· Needs Work: missed a requirement, missed some tests, something caused an error.

This will send the requestor an email to let them know it’s done, and the entire team will see the comments you added in their email. It will take the code review off of your list of incoming requests, but it will not be removed from the rest of the team’s list until the requestor closes the review.

Finally, open up the user story and record your name and hours under the code review task.

Checking In

Only check in code that has been reviewed, unless it is a very minor tweak or you did pair programming while writing the code.

Suspend all pending work first, then open the completed code review from the “My Code Reviews & Requests” list in the Code Reviews area of the My Work tool.


1. Click the link to activate the change set so that you get all your changes into your work space. Review any comments provided and make any changes.

a. If you have questions about the review, it’s probably best just to go talk to the reviewer at this point.

b. We don’t generally send a second review request after changes unless the requestor feels there were a lot of changes and they would like them to be reviewed. In this case, create a new code review just for the developer who originally reviewed your code.

2. Close the review. This will mark the user story as resolved and remove the code review request from the teams’ list of incoming requests.

Now that your review is closed, make sure to check in your changes on the Pending Changes tool. Also, move the printed card from the In Review area over to the Completed/Merged area on the task board.

How to Customize the Available Work Items Query in Visual Studio Team Explorer

In Team Explorer’s Work tool, there is a section for Available Work Items that shows all the user stories, tasks, and bugs that are active and not being worked on. The default query may be overwhelmed by stories or tasks that aren’t development related. You can change the query to just show your user stories.



1. Make sure the project is set to your intended project.

2. Set the query to Current Iteration, then click the Open Query link

3. Click on the Edit Query


1. Delete the state = Resolved line

2. Add a new line for Area Path Not Under Project Admin

3. Save this query and give it a name.


1. Use the drop down in available work items to select your query.

2. See the items assigned just to you below.

Outlook Email Rules Configuration

The code review process generates a lot of emails, so you may want to setup an Outlook rule to help manage them.


Create a rule as above that sends anything from your TFS email address with Code review in the subject to a special code review folder.

Inside the folder, you can rt-click on the grid header and add Subject into the columns, then sort by Subject and check Show In Groups.

What do I have checked out in SharePoint (2013)?

1. Open SharePoint in your browser

2. Click on the ellipsis and select “Create View”: clip_image002

3. Choose “Standard View”

4. Enter a view name “Checked Out”

5. Check the box for “Checked Out To” in the Columns section

6. Sort by “Name (for use in forms)”

7. In the Filter, change it to only show when “Checked Out To”, “is equal to”, your name

8. Down in the Folders section, choose “Show all items without folders” – this will let you see what’s checked out across the entire library instead of just the current folder

For a view that shows what’s checked out by anyone, change step 7 above to be “Checked Out To”, “is not equal to”, and leave the text box blank.

How to create a Visual Studio 2013 Database Project in 10 Minutes!

Watch my Pluralsight Author Audition video to learn how to create a Visual Studio 2013 Database Project from an existing SQL Server database and populate it with data from that database.

After you’ve created your database project, you can publish it to your development environment for a consistent development database that reduces the risk of data integrity bugs sneaking in.

Improve Team Collaboration with Visual Studio 2013 Database Projects


Approximate transcript:

Have you ever been part of a team who has had problems coordinating changes to the database during development or while publishing your work to production? Wouldn't it be nice to have some reliable and consistent test data that you can use while developing and debugging a new feature?

Hi, I'm Rusty Divine and in this course on improving team collaboration with Visual Studio 2013 database projects I am going to show you how to create a consistent data set for each member of your team and overcome database conflicts by creating a database project that can be published on your local machine at the click of the button. After watching this course you will be ready to create a new Visual Studio Database Project with test data so that you can develop your new features in isolation of any model or data changes by other team members.


On many software development teams more than one developer makes changes to the database. A team might use a shared development database on a server and have worked out a system to handle breaking database changes and buggy data that creep in. Some teams can script each change they make to the database model and seed data, then update or rebuild the database to any version they need to by running each script in order.


An option that has worked well for teams that I have been part of is to use a database project to manage the model and test-data changes. Database projects work well when the development of the solution will take months to years to build and the team of three or more will each be helping make changes to the database. The database project is a good option because it:

  • Gives developers a local database sandbox
  • Provides consistent data that can be wiped and reloaded when data integrity bugs creep in
  • Makes merging into your version control system easier than having to merge scripts that are dependent on the order they are ran
  • Allows reuse on automatic builds to publish a consistent database that automated tests can be written against


Some potential drawbacks to database projects are:

  • Setting it up the first time takes time
  • On a new project where you are working to define the database and it is changing rapidly, it can feel like this takes you out of the develop-test flow
  • When moving to QA and Production you need to do a model comparison to generate change scripts and create any data motion scripts you need to change data in each environment

Let's take a look at what it will take to get a database project added to your solution.


We'll be using this Northwind database to represent a backup of your development database where you've taken the time to get just the data you need into it - the less data the better because it will take less time to publish that way.

I've created a database project using the default settings from rt-clicking on this database and selecting create new project. You can see it has brought in all of the tables, views, and other schema, but it did not script the data.

Here I've added a scripts folder and a post-deployment folder to organize the data load scripts. Now, there are several ways to get the data scripts generated, but the way I find works best for a set of data that isn't reaching into the hundreds of thousands of rows is to use SQL Management Studio's script generation; for larger data sets I would recommend SSMS tools (pop-up a link).

In management studio, I will right-click on the database and choose to generate scripts. I want to select just the tables and then choose to generate a separate file for each. In the advanced settings, I choose to not generate the use database commands and change the export from schema to data. Now I'll export it to the post-deployment folder we created in our project.

I've shown all the files here in the project and want to include our new scripts. Now I need to set the build action to none for these so that they aren't included in the publish because I want to control the order of them.

Next, I will add a post-deployment script that will execute each of these data loads in the correct order that does not conflict with their foreign key relationships.

The format for running these is to use this colon-r followed by the script location to run the script. The script uses command syntax, so I will turn on sql command mode.

Now, I'll paste in the rest of the tables. When I try to build, I see an error with the order details table. Looking at it, I see that I need to add some quotation marks around it, and now it builds fine.

Let's publish this database to see our data. Rt-click on the project and choose publish. In the advanced mode, I want to choose recreate the database every time. There are ways you can merge this data into an existing database, but I want to make sure I wipe out any data related bugs that may have crept in and start clean each time. I'll save the profile for later use, and then click on publish.

There was a problem publishing the database, so I'll click this link to view the results. Here, I can see the script it generated and I could copy/paste this into SQL management studio to troubleshoot, but looking at the messages, I see there was a problem with the self-referential key on the employee table. I know that's going to be a problem to load, so I'll just drop the key before I load the table, then re-add it after.

Now, let's publish from the profile we saved. You can see it published successfully, and if I go into management studio and refresh the databases, there is our new database and you can see it did bring over our data.



In this course we covered the benefits of having a consistent development data set for your team so that they develop and test their work in isolation.

We covered how a database project can

  • Help your medium to large team coordinate model and test-data changes
  • Provide an isolated sandbox to develop new features
  • Wipe out any data-related bugs that creep in during development

There are a lot of extra features that you can explore with database projects, and I'd encourage you to watch these other Pluralsight courses to learn more.

Tech Training–Hour of Code, CSS3 Selectors, new Team Goal

TechTrainEvery Friday our team meets for two hours to work on something together. We’ve scratched the surface of many topics to get a feel for what is possible and dug deeper into others that we want to implement on our project. The adjacent mind map shows about a year’s worth of training (taken from our PM’s whiteboard for his talk on why we do technical training).


Hour of Code

Today our PM presented some things his young daughter did in the recent hour of code – a fantastic event to get kids (and adults) interested in programming. We also took a look at the similar Santa Tracker by Google where like an advent calendar there’s a different programming game or puzzle available every day in December leading up to Christmas. We had a ton of fun navigating our elves through mazes and flying them through the sky to pick up presents.

CSS3 Selectors

We’re always looking into fun ways to practice our skills, and what better way than a rewarding little game of CSS3 selectors! If you do any web programming, you should try this out: It took our group anywhere from 30-45 minutes to complete the 26 challenges and along the way you could hear many quiet refrains of “Yes!” and “oh-yah!”. It’s great to hear everyone having a great time and learning, too.

I gave the team some more resources to read up on in their own time, too:

Docs -

Interactive -

Tutorials - (work through the menu on the left or click Next Chapter)

Team Goal

Our team works on personal goals and team goals. An example team goal was to upgrade our source code tool (TFS) and development tool (VS) to the latest versions. That took a major effort because it ended up getting bundled with an operating system upgrade (Win 8.1) and pushed out across our organization.

During the last 20 minutes of our tech meeting today we brainstormed what our next team goal should be. It needs to be something that takes a few months to a year and benefits the whole team.

We put up a list on the whiteboard as we brainstormed, and then each team member emailed me their three votes from the list (and they could vote more than once for any idea). The final tally of votes was:

  • Kendo UI upgrade (4)
  • MVC 5 upgrade (3)
  • EF6 upgrade (2)
  • SQL 2012 upgrade (0)
  • Visual studio upgrade (0)
  • Requirements Gathering/Analysis training (6)
  • Mainframe administration training (2)
  • JavaScript testing/improvements in our project (2)
  • Move automation/dev ops for better continuous integration (2)

I was excited to see the team want to work on requirements gathering and analysis training because I really enjoy those (I’ve given a couple of talks and am working on a Pluralsight course on the subject), and because it was one of the soft skills in a team who really loves the tech-side.

We’ll work on how to learn about a problem from our customers, how to ask why enough times to find out the real business reason, practice how to come up with a good plan for a complicated process, and more. We’ll watch some Pluralsight courses and dedicate some training days to getting better – I can’t wait to get started! It’s so good to get a direction set by the team that you know has the whole team’s buy-in; everyone wants to get better, we just need to provide the right environment to make it possible.

A System for Technical Training–How and Why Your Team Should be Learning

Graph drawing on blackboardThere is something you should be doing to help yourself grow - practicing your craft. You may feel like you don't have the time or the energy to do it outside of your regular responsibilities. Maybe you've tried off and on, or maybe the thought of it conjures negative feelings. Sometimes it feels more rewarding to just keep working through tasks and checking them off the list than to switch to work on something that by its nature makes you struggle and thrash and can feel aimless like you are putting in more work and just not having any way to measure a payoff. Sometimes you aren't even allowed to study on the job.


You need to remove as many obstacles as you can to make Learning something that you practice consistently. So, what is stopping you? What's getting in the way of your team from spending the time it needs to get better?


Common obstacles include the following:

  • Why should we set aside time for learning?
  • When can I study and practice?
  • What do I study? Where do I start?
  • Should it be something directly related to what my company does?
  • How much time should I spend?
  • What's more important, learning or finishing a task?
  • How do I know I'm getting better?
  • Do I have to?


Let me tell you what my team is doing to remove most of these obstacles and how it is invigorating us.


Hamster Running WheelWe have recognized that there is a significant risk of burn-out if a team has a never-ending backlog of work to do. We need regular breaks that mark and acknowledge the work we've done while allowing our minds to relax and regroup for the next push. Our team plans three weeks of work at a time and marks the end of the cycle with a demonstration to the end users, a retrospective of what went well and what could have been better that helps us continually improve, a day off from our daily 15 minute stand-up meeting, and an afternoon with nothing to do other than learn something new.


We also dedicate two hours every week  on Friday mornings from ten-to-noon to group training where the tech lead (that's me for now) prepares something for the team to work on together. It could be improving a skill that helps the team or training on a new technology that we are considering adopting. We've used these meetings to learn and practice TDD, explore Azure, test out new versions of Visual Studio and TFS, start new projects from scratch, and pick a new technology to implement a small prototype in, just to name a few.


Our team has MSDN Universal, which comes with $150/month credit to Azure that we can use to run virtual machines and websites. We also all have Pluralsight Annual Plus subscriptions that we are encouraged to use for our allocated training time and also that last 30 minutes of the day that can be otherwise unproductive if you've wrapped up your work.


We enter our time in TFS for our stories and we track that we are each entering at least six hours a day. We have set aside time in TFS for training that including the two hours each Friday comes out to at least four hours per week (a little more would not be frowned upon).


At one of our retrospectives recently we talked about some problems we were having making ourselves take the allocated time for training instead of just working on tasks. We made some adjustments to our schedule, agreed as a group that training is higher priority than adding unplanned tasks to our iteration, and decided to assess our skills so that each of us can focus on the areas we needed most.


We each took the Pluralsight tech pro challenge over at Smarterer and had a lot of fun grousing about the questions and learning how we stacked up to the average developer. Based on each of our lowest scores, we picked courses from Pluralsight to watch that would most help improve our skills. We will then take their assessments to demonstrate our proficiency and also come up with a simple project to present to the rest of the group that covers the new skills we learned. Our progress will be tracked by our supervisor, but also the team as a whole will benefit because each of us will be better at our jobs and each of us will teach what we have learned.




Sometimes the best solution to a problem is creating a system or process that you can follow where the solution just falls out naturally. We have to learn because we've setup a process that leaves us no choice; we have the time set aside, we have identified what we need to focus on, and we have made ourselves accountable to our supervisor and to each other. We no longer struggle with not knowing what direction to go, or whether or not we should study or find a task to do, and it feels empowering and easy and just downhill.

From Idea to Core Feature Set–Heartland Developer’s Confernce 2014

Thanks to everyone who worked on HDC this year to make it a great success!! I really enjoyed meeting with everyone and talking with those that came to my talk From Idea to Core Feature Set.

Here are the slides and examples for download: (3.4MB)

Let me know if you have any questions!

Heartland Developer Conference 2014

I’ve been attending HDC for about 4 years and I’m happy to say I am presenting this year! Register now and come see my talk titled From Idea to Core Feature Set where I’ll show you how to take an idea for a product or an initiative at work and get to a shared vision of what is really most important and what really needs to get done first.

How To Make Gourmet Burgers

Cooking is one of my favorite hobbies. I love tweaking recipes to try new flavors and learning about different combinations that go well together. It’s one reason I love Cook’s Illustrated because they teach you by telling you all the things they tried while perfecting their recipe.

I also love burgers, and there’s a few places in Lincoln, NE that really are doing great things with burgers:

  1. Honest Abe’s
  2. Gretta’s Gourmet
  3. HF Crave

There’s a burger at Honest Abe’s that a friend of mine orders every time (the 1809 burger). I told him that my summer project is to develop a burger that he would order instead of that burger – one that surpasses its savory excellence. I’ve taken the first step towards that goal by creating a repository to version my recipe until it is perfected, and a video to teach you how to make a gourmet burger in your backyard. Enjoy!

Making Gourmet Burgers