Pivotal Labs

Main menu

Skip to primary content
Skip to secondary content
  • About
  • Case Studies
  • Team
    • Executives
    • Locations
      • San Francisco (HQ)
      • Boston
      • Boulder
      • Denver
      • London
      • Los Angeles
      • New York
  • Community
    • Blogs
    • Tech Talks
    • Events
  • Careers
    • Lifestyle
    • Principles & Practices
    • Benefits
    • FAQ
    • Apply
  • Contact
    • Press Room
    • Press Releases
    • In The News
    • Press Kit
  • All
  • Labs
  • Standup
  • Tracker

Gansen and Kunesh on Agile Development in the Obama 2012 Campaign

Paul Davis
Tuesday, May 14, 2013
Juan Camilo Bernal / Shutterstock.com

Juan Camilo Bernal / Shutterstock.com

 

The Obama 2012 campaign has been hailed as the most tech-savvy and data-driven to date, a sophisticated operation led by CTO Harper Reed. Reed had no problem finding developers eager to join the campaign — the challenge was finding people up for the formidable task before them. A Presidential campaign poses unique challenges: an environment where volatility is the only constant, developers must iterate often, yet there is little margin for error. To meet this challenge, Reed and his team placed an emphasis on people who could resolve problems and learn quickly, rather than focusing on a particular skill set.

Within this heady environment, Chris Gansen, the campaign’s Senior Software Engineer, and Jason Kunesh, Director of User Experience and Product, embraced the methodologies of agile software development.

While much attention was paid to the Obama 2012 tech team’s online voter outreach efforts, its on-the-ground campaign was equally impressive, turning information collected by volunteers knocking on their neighbors’ doors into grist for fine-grained data collection and analytics. This was undertaken by roughly “1000 neighborhood teams with tens of thousand of volunteer leaders,” according to Gansen.

A voter outreach campaign of such size and complexity demanded a bi-directional communication and data collection tool. Gansen and Kunesh were deeply involved in building the resulting product, Dashboard, which gave volunteer leaders a way to connect, organize, and report progress. Dashboard became a gold mine of voter-reported data, providing the campaign with insights and strategies to effectively communicate to voters and coordinate volunteers, at both a macro and micro scale. Gansen describes the lauded voter outreach and analytics platform as “the culmination of many years of trying to unify online and offline campaign organizing.”

Dashboard grew to one of the largest projects within the campaign, boasting 40–50 engineers divided between five separate tracks, or “Work Streams,” as they were known within the campaign.

From Agile Skepticism to Proven Success

Comfortable with the proven, tightly managed, topdown management model of campaigns past, veteran politicos were initially skeptical of agile development practices. “We fought really hard to get people in the campaign to embrace iterative development,” says Gansen. “In government, you tend to see technology coming from vendors, and measured by the quarter. When we would say, ‘we’re going to launch this and there are going to be bugs,’ a lot of people in the campaign hesitated. They hadn’t done this before, and we had to be flawlessly representing the brand of the President.”

“Software isn’t like that,” he says. “It can be messy, and so we had to show them through iterating, and being accountable to what we were doing, that things improved over time.” Despite their initial pushback, the clarity and transparency of this approach won converts among the skeptics. “We had great technologists who’d never worked on campaigns, and great campaigners who’d never participated in shaping software,” says Kunesh. “Before we understood each others’ worlds, agile was a way for us to agree on what we were building and how.”

It also allowed them to prioritize high-value goals and milestones, while being able to quickly change course when necessary. “Since the goals of the campaign change depending upon what phase of campaigning you are in, responding dynamically was a requirement,” says Kunesh. “The things that were important in February are meaningless at the end of summer, but they are the features you needed in the spring. Agile helped us stay focused on shipping the most important features.”

The campaign measured every conceivable metric — voter data, usage and performance at every level of the technology stacks, and project velocity, to name a handful of metrics. Gansen, Kunesh, and their teams turned to Pivotal Tracker to collaborate, track progress, and perhaps most importantly, communicate their workload and progress to other stakeholders in the campaign. Tracker’s emphasis on agile development methodology, prioritization and collaboration was well-suited to the environment. For the Dashboard initiative, each of the five work streams were divided into separate Tracker projects. Every feature on the Dashboard project had a corresponding Tracker story, and they used release markers heavily to represent milestones.

“With very constrained time, we had to decide quickly whether to improve a feature or axe it,” says Gansen. “In campaigns, you never make a decision that isn’t backed up with data, so being able to pair data-driven development with agile delivery helped build products that people actually used.”

Gansen found that Tracker and agile development practices helped the team make the case for decisions, clearly demonstrate what milestones had been reached, and accurately predict when upcoming milestones would be hit. “From a product perspective,” he says, “the two things that were most successful was the transparency and the accountability of quick, weekly releases. We were able to say, ‘this is what we’re going to do,’ and then a week later come back and say, ‘we did what we said we would do, and if we didn’t, here’s what came up.’”

It also eased the process of onboarding new developers, Kunesh says. “It gave us a common platform and methodology to follow,” he says. “We were building our team as we were building our products. Pivotal Tracker offered a built-in workflow that let us move engineers from team to team while still having a common process.”

Battle-tested and Unbowed

The members of that team have gone their separate ways, like the tech industry equivalent of a pack of sage cowboys riding off into the sunset. Products such as Dashboard now lay in hibernation until the next election season. Fortunately, the likes of Gansen and Kunesh are sharing the hard-learned lessons they learned during those intense 18 months.

Gansen, who now consults for the civic technology organization Smart Chicago Collaborative, has developed a healthy obsession with collecting and analyzing all the data one might have available. “Measurement is key because you can’t make decisions on information you don’t have,” he says. “Measure everything, and do it early on, because even with a small amount of data, you can make decisions. Over time, the data only grows more and more valuable.”

Both Gansen and Kunesh evangelize for the value of developing and deploying transparently within an organization, and using that openness to engage nontechnical stakeholders. It’s a matter of “Communication and building trust,” Kunesh says. “Operate openly and transparently with what you’re doing with the people involved in the process,” Gansen adds. “When a technical team is interacting with a nontechnical team,” he says, such clarity and transparency “is essential.”

  • 0 Shares
  • Share on Facebook
  • Share on Twitter
Dan Podsedly

Monday’s Tracker Outage, New Status Page

Dan Podsedly
Wednesday, April 24, 2013

This week started on the wrong foot with a 1 hour and 45 minute outage early Monday morning, that affected many of you. I’d like to apologize for this, and shed some light on what happened.

It began as a network outage at our hosting provider’s data center, which was resolved fairly quickly. Unfortunately, Tracker’s load balancers did not recover correctly, as they should have automatically, and to complete the perfect storm, the alerting mechanism that’s supposed to notify us and the hosting provider’s operations team did not work either due to misconfiguration.

The load balancer configuration issue has been corrected, and we’re confident that this problem will not occur again. Tracker’s production environment is designed to recover automatically from network and other types of outages, and our hosting provider monitors and responds to problems on a 24/7 basis.

To help you determine if Tracker is experiencing an outage in the future, we’ve enabled a public status page for Tracker, via Pingdom, one of the site monitoring services that we rely on.

Screen Shot 2013-04-24 at 11.04.48 AM

To keep up with the latest updates, please follow @pivotaltracker. And to get help, visit https://www.pivotaltracker.com/help or email tracker@pivotallabs.com.

 

 

 

  • 0 Shares
  • Share on Facebook
  • Share on Twitter
Lisa Crispin

Making testing visible in the Tracker workflow

Lisa Crispin
Friday, April 5, 2013

As a feature story progresses through the Tracker workflow, a lot of testing activities are also underway. Team members are collaborating to turn examples of desired behaviors into business-facing tests that guide development. Testers are performing manual exploratory testing on stories as they are delivered. Performance or security testing may be underway at some point in the development process.

A testing workflow?

To keep things simple, Tracker’s states are limited to Not Started, Started, Finished, Delivered, Accepted and Rejected. Only the “Accepted” and “Rejected’ states seem directly related to testing. Testing activities such as specification by example, acceptance testing, exploratory testing, load testing, and end-to-end testing aren’t reflected in the Tracker workflow, but they’re going on nevertheless. Testers, coders, product owners and other team members continually talk about how a feature should work, and what to verify before accepting a story as “done”. But details can still be overlooked or lost. If stories are rejected multiple times because of missed or misunderstood requirements, or problems slip by and aren’t discovered until after production release, testing activities need to get more attention.

We’re working on enhancing collaboration and communication in Tracker, with increased flexibility that will help with tracking testing activities. Meanwhile, how can Tracker users follow testing along with other development activities? It would be helpful to have a place to specify test cases, note plans for executing different types of tests, and make notes about what was tested. Accomplishing this requires a bit of creativity, but it’s possible to keep testing visible in the current Tracker workflow. Here are some ways we do this on our own Pivotal Tracker team.

Testable stories

First of all, we work hard to slice and dice our features into stories small increments that are still testable. We read the stories in the backlog to make sure we understand what each one should deliver, and how it can be tested. If I have questions about an upcoming story when we’re not in a planning meeting, I note it in a task or comment to make sure we talk about it. Iteration planning meetings are a good place for the team to start discussing how each story will be tested. Some teams get together with their business experts to help write the stories with this in mind.

We make sure we know how we’ll test all the stories in the upcoming iteration. There are a couple of different ways to get enough of this information into the story .

Using tasks and comments

Test cases and testing notes can be added to a feature story as tasks. They’re easy to see in the story, and can be marked as completed when done. We often include links to additional details documented in a wiki page, or to automate-able functional tests used for acceptance test-driven development (ATDD). As teammate Joanne Webb points out, sharing test cases before implementing a story clarifies requirements, and gives developers clues on problems to avoid introducing. In our experience, this shortens the accept/reject cycle for stories.

Comments are another good place to add information about requirements and test cases, especially since you can also attach files with additional information, screenshots, pictures of diagrams, and mockups. And if team members have questions they can’t get answered in person right away, comments provide a place to record a written conversation, and email notifications can alert the story owner and requester so they can answer questions.

Visibility and workflow through labels

We can find ways to record conversations about requirements, but how do we incorporate a testing workflow into the larger development workflow for a Tracker story?

TestingExample

Labels are a handy way to keep stories progressing through all coding and testing tasks. In our Tracker project, automating functional tests is part of development. The story isn’t marked finished until both unit tests and functional tests are checked in, along with the production code. Once a feature story is delivered, someone (usually a tester or the product owner, but it could be a programmer who didn’t work on coding the feature) picks up the story to do manual exploratory testing.

To make this visible, we put a label on it with our name, for example, “lisa_testing”. Not only do we conduct exploratory testing, we verify that there are adequate automated regression tests for the story, and that necessary documentation is present and accurate. Once we’re done testing a feature story, we put a brief description of what we tested in a comment, remove the “testing” label, and add another label to show the story is ready for the product owner to verify. This might be “lisa_done_testing” or “ready_for_dan”. Sometimes the product owner gets to the story first, and uses similar labels to show he’s in the process of testing or finished with his own acceptance testing. Once all involved parties are happy with the story, we can accept it. Using labels is a bit of extra overhead, but it gives us flexibility to continually improve our acceptance process.

Putting together a bigger picture

Some testing activities extend beyond one story, especially since we usually keep our stories small. It’s possible to write a feature story or chore for the testing activity. For example, you might write a story for end-to-end testing of an epic that consists of many stories and extends to more than one iteration. Writing a chore for performance testing, security testing, or usability testing may be useful.

However, as my teammate Marlena Compton points out, there are advantages to making sure testing is integrated with the feature stories themselves. If a story remains in delivered state for several days while we complete system testing related to it, the labels we put on the story convey the testing activities underway. Completing all testing before accepting a story helps ensure the stories meet customer expectations on the first day. As Elisabeth Hendrickson says, testing isn’t a phase, it’s an integral part of software development, along with coding and other work. Having our Tracker stories reflect that helps keep us on target.

As we do exploratory testing on a feature story, we might discover issues or missing requirements that don’t make the story un-shippable, but may need to be addressed later. We can create separate feature stories, bugs or chores for those, and link back to the original story via links or labels.

We track some testing information outside of Tracker, for example, on our team wiki. However, we find that tracking testing activities in Tracker helps ensure that they get done in a timely manner, and keeping tests visible helps ensure that stories meet customer expectations the first time they’re delivered. Integrating testing activities with coding tasks keeps our testing efforts aligned with other development efforts.

While we work to make Tracker more flexible for teams and testers, we hope these ideas help you make your testing more visible in the Tracker workflow right now. Check out our blog post http://pivotallabs.com/2013-update-new-features-new-api-new-design/ to get an overview of some of the plans for Tracker this year, and come back periodically for the latest news. We’d also love to hear how your team incorporates testing in agile development. Please leave a comment, or write to us at tracker@pivotallabs.com.

  • 0 Shares
  • Share on Facebook
  • Share on Twitter
Jared Carroll

Why are all the Stories in Pivotal Tracker Missing Descriptions?

Jared Carroll
Sunday, March 24, 2013

I asked my pair on my first day here at Pivotal.

That’s on purpose. A user story is a promise to have a conversation. When we start a story, we’ll have a discussion with the client to fill in the details.

Ok. So we’ll just ping them on Skype or something?

No. They’re sitting at the desk right over there.

The Onsite Customer

In XP, the onsite customer is a domain expert that is part of the development team. Their responsibility is to answer questions, resolve disputes, and set small-scale priorities [1].

In past projects, contacting a client involved emails, IMs, or phone calls. My stories needed detailed descriptions. Description-less stories risked building the wrong thing. So I labeled them “blocked”, and project velocity suffered.

Benefits of having an Onsite Customer

In my current project, having an onsite customer has made a huge impact.

Eliminating story descriptions has simplified iteration planning meetings. Just write down a short title and move on. Discuss the details later.

Constant client communication has helped avoid misunderstandings. Not once has a pair built the wrong thing. Developer time isn’t wasted.

Delivered stories rarely go untested for longer than an hour. A quicker turnaround has shortened system feedback time.

Get Serious About Succeeding

An onsite customer was one XP practice that was missing from my past projects. What client would be willing to give up one of their full-time employees? After four weeks of working on a team with an onsite customer, to me, the answer is clear: a client that wants their product to succeed.

[1] Kent Beck, Extreme Programming Explained: Embrace Change (Addison-Wesley Professional, 2000), 60.

  • 0 Shares
  • Share on Facebook
  • Share on Twitter
Joanne Webb

6 Third Party Tools for Automatic Bug Creation and More

Joanne Webb
Tuesday, March 12, 2013

3rdPartyToolsForTestLogosPivotal Tracker lets you stay on top of everything to do with your project, but sometimes your stories need a little something extra.

Fortunately when some of our customers feel that way, they share the results. Here’s a roundup of recent test related Third Party Tools to help you make the most of your bugs in Tracker.

Bugherd is a website annotation tool, that lets you capture bugs, feature requests, etc.,  by clicking the offending element on your pages using BugHerd’s simple overlay. With this integration, this feedback can be sent straight to Tracker.

Bugsnag allows you to automatically create bug stories in Tracker when a crash is detected in your web and mobile applications.

HoneyBadger error management app users can link their apps to their Tracker projects. When a bug comes in, they can press a button to create a story. The bug stays linked to the story so that users can easily jump to Tracker from Honeybadger.

PivotalFeedback can be hooked up to a “Feedback” link, for example, to allow users to easily submit bugs, features, and chores to Tracker, with all the information you need.

Testrail is a test management tool for QA and software development teams. It integrates with Tracker so you can link test results to stories, push bug reports and look up the details of stories directly from TestRail.

Redline allows  anyone to point out bugs directly onto a web page without having to sign in to Tracker. Instead, their notes auto-generate a story in Tracker, along with a URL that shows the markups on the original web page.

Don’t forget to look in on the integrations we’ve created as well, including Bugzilla, Lighthouse, Jira and the ability to create connections to other tools in Tracker.

  • 0 Shares
  • Share on Facebook
  • Share on Twitter
Christian Niles

Pivotal Tracker for iOS 1.6.1 fixes Romaji and other text input issues: 失礼しました。

Christian Niles
Wednesday, March 6, 2013

We’ve just released version 1.6.1 of the Pivotal Tracker iOS app, which includes fixes for a number of text input problems.

Most importantly, it fixes Romaji input for Japanese users. While we don’t officially support non-English localizations, we try our best to allow Tracker to be used in any language. This release also fixes a similar bug that prevented auto-completion, spell-checking, and text shortcuts from working in text fields.

Dragging stories is also snappier in this release, because we’ve reduced the delay before beginning a drag. To recap, stories can be dragged to a new location by touching and holding a story for a short time with one finger. We include a momentary delay, otherwise stories would get moved while scrolling through story panels. Touching a story with two fingers will immediately begin dragging a story, which I find really convenient and useful on an iPad.

The new version can be downloaded from the App Store, and we welcome your feedback in the Pivotal Tracker community forum.

  • 0 Shares
  • Share on Facebook
  • Share on Twitter
Dan Podsedly

Browser support in Pivotal Tracker

Dan Podsedly
Wednesday, March 6, 2013

As we recently wrote, 2013 will see major improvements to Pivotal Tracker, on a rebuilt foundation (including a brand new API), followed by major new features and an updated design.

We can’t wait to get all this into your hands quickly, and continuously improve Tracker based on your feedback. As we all know, though, making web applications work well in all of the web browsers out there can be extremely time consuming, even impossible in some cases. In order to focus our energy on product improvements, and take advantage of modern open source technologies, we will be limiting “official” support to recently released versions of the most commonly used web browsers, specifically:

  • Google Chrome (version 22 and above)
  • Mozilla Firefox (version 17 and above)
  • Apple Safari (version 6)
  • Internet Explorer (version 9 and 10)

The good news is that most of you are already using these modern browsers.

Tracker will likely work reasonably well in other types of browsers, or older versions of the above, but you will soon see an unsupported browser warning in Tracker, and may run into issues, including slower performance. Hopefully upgrading to one of the supported browsers above is not too much of an inconvenience.

If you’re limited to using an on older version of Internet Explorer, we recommend installing the Google Chrome Frame plugin, for much better compatibility with modern sites and web applications.

We will be gradually rolling out under-the-hood modernizations over the next few weeks, and getting started on the first batch of new features. Stay tuned!

  • 0 Shares
  • Share on Facebook
  • Share on Twitter
Ronan Dunlop

Tracker Ecosystem: Tracker Tracker – cross project visibility and panel customization

Ronan Dunlop
Monday, March 4, 2013

Tracker Tracker is an open source web app that allows you to see and work with stories from across multiple projects in one Kanban style view, with search and filtering. That’s huge. We have nothing else to say on the matter really. For anyone juggling multiple projects in Pivotal Tracker this is a must consider app.

On a side note, rumor has it Tracker Tracker was built to prevent a team’s possible migration to another tool. We’re literally speechless when our community does stuff like this, but not so tongue tied we can’t say thank you!

Here are just a few of the cool features and benefits we’ve lifted directly from the Tracker Tracker github page:

  • Simultaneously view and manage stories across multiple projects
  • Scrum-like UI displays one column per story state
  • Search across all projects simultaneously
  • All labels for all projects are visible and have epic-like mini progress charts
  • Columns can be rearranged
  • Labels, searches, column order, selected projects all survive browser restart
  • It’s pretty easy to write custom columns and filters
  • Forecasting charts

tracker tracker

 

  • 0 Shares
  • Share on Facebook
  • Share on Twitter
Christian Niles

Greatly Refined Story Editing in Pivotal Tracker for iOS 1.6

Christian Niles
Wednesday, February 27, 2013

Download Pivotal Tracker for iOS v1.6Today we’ve released Pivotal Tracker for iOS 1.6 to the App Store. With this release we’ve thoroughly refined the app to make updating stories easier and more enjoyable. While there are all kinds of refinements, we think you’ll be most excited about the following:

All text can now be edited inline

A story’s name, description, tasks, and comments are all editable inline, without transitioning to a new screen and losing context. While editing, text now wraps gracefully across multiple lines as you type.

For example, previous versions of the app provided a separate screen for creating a comment. In version 1.6 this now happens inline, right where the comment will be added. This allows you to continue to scan other comments or details about the story as you write.

Managing labels is easier

Finding and adding labels to a story is much improved, especially for larger projects. The label list now filters as you type, which helps avoid duplicate or mistyped labels. Adding a new label is also much more obvious and easy.

Moving Tasks doesn’t require a separate mode anymore

All tasks can now be moved using the standard move controls, without the need to go into “move” mode. This gets rid of a needless extra taps. To remove a task, simply swipe it and tap the “Delete” button.

Moving or Deleting a story are both more accessible

We’ve gotten rid of the separate “Action” screen, and replaced it with a pair of buttons to move or delete a story. You’ll find these at the very bottom of the story editor, rather than the old icon in the title bar.

We hope you love this release! Please don’t be shy about letting us know in our community about how we can continue to make the app better.

  • 0 Shares
  • Share on Facebook
  • Share on Twitter
Ken Mayer

It’s The Volatility That Will Kill You

Ken Mayer
Tuesday, February 19, 2013

Volatility is what Pivotal Tracker uses to measure the consistency of your team’s work output. You can use that number to help you estimate the first approximation to answer the eternal question, “Will I make the deadline?”

One fine day at the office…

The Project

You’ve scoped out 100 points worth of stories for the Next Big Release™. Pivotal Tracker shows your velocity is 10 points per week. Your annual review is in 3 months and on-time delivery of this high profile project will figure prominently.

The Boss Then the CEO walks over to your desk and asks, “Will I make the launch date, 10 weeks from now?”

What do you say?

  1. “Yes, my lord. Of course we’ll make our date! I’m 100% certain of it; Behold; Tracker says we’ll finish in 10 parsecs.”
  2. “Probably; We had some iterations that cleared 30 points, but last week we were working on bugs and only accepted 2 points. A couple weeks of those and we might miss the deadline.”
  3. “There’s no clear answer. There are so many other uncertainties, technical debt, QA, deployment work.”

It’s a trap!

It's A Trap!Hopefully, you answered with “none of the above.” Velocity is just one measure of how your project is performing. Staking your career on it would be foolhardy. The second answer is honest, yet hopelessly vague. The third reply is why many people still think Agile is a way to duck your responsibilities as a software professional. There is hope, however; We can use Pivotal Tracker’s tools to make a better (albeit imperfect) estimate.

Past Performance is No Guarantee of Future Returns, but Yesterday’s Weather is Often Good Enough

Velocity, week over week, varies; sometimes a lot, sometimes a little. It depends on the project. Ideally, each iteration would have the same mix of stories, bugs and chores and Velocity would be very consistent. Steady velocity is a good thing™. In the real world, however, all sorts of things crop up; Your head-count goes up (or down), business priorities shift (or pivot), deferred technical debt demands payment, quality assurance files a slew of bug reports, user testing reveals flaws in product, visual design changes. The real world creates volatility in your Velocity.

A simple measure of this is standard deviation, which Tracker constantly computes for your project. Using that metric, you can decide what you should watch or change in order to meet your goals. Let’s go back to our example and look at the velocity charts in Tracker.

velocity

Assuming that we have a normal distribution of weekly velocities, the first sigma (±35%) will fall into the range of 10±3.5 points each week. That is, there is a 70% probability that your project will deliver all 100 points somewhere between 8 and 16 weeks. Why so much spread? 40% volatility is a big number! In the worst case scenario, where every iteration delivers only 6.5 points, it gets you to your goal in 100 ÷ 6.5 ≅ 16 weeks.

burndown

I Find Your Lack of Faith Disturbing

By now, you’ve had your meeting with the CEO. You’ve shown him the stories left in the backlog, the volatility of the project, and the range of estimates for delivery. This is the beginning of a conversation. If you’re team is not comfortable with the worst case scenario, something must change and, really, you have only two choices; you can reduce volatility or you can reduce scope. You will probably need to do both. Alas, there is no simple formula here. This is where skill, experience and insight will come into play. Here are some suggestions:

Reduce Volatility

  • It’s critical that stories are accepted as soon as possible after they are delivered. Is the project manager unable to accept stores as they are delivered, so they don’t get credited in the iteration where they started? You can backdate acceptance to reflect when the stories were ready (rather than when the PM accepted them), but it is not something I would do on a regular basis.
  • Are the stories marked as bugs and chores *truly* overhead, or are they “stealth” features? Does the story add business value to the product? That’s a feature. Flaws introduced by feature stories are bugs. Design changes surfaced by testing is a new feature.
  • Are there too many stories in flight? Can you deliver stories more reliably by starting fewer at a time? Study after study shows that human beings do not multitask well at all. Do one thing, do it well, then move on.
  • Are there blocked tracks? Do stories get stalled because of dependencies? Can you reorganize your backlog so each story is independent.
  • Are there outside resources, out of your control, that are introducing volatility?
  • Multiple rejected stories are toxic. If your team is getting more than one or two rejects each week, this may be a sign that your stories are not accurately representing what your product manager intended. It’s time to look at your work flow to prevent them from happening so often.
  • Are you not refactoring enough? Constant, steady refactoring, delivered during each story is much better than giant refactors that last a week. You should consider refactoring as critical to your process and not something to do “later, when you have more time for it.”
  • Make all of your projects small by breaking them up. Delivering a project on time is always tricky business. I’ve discovered that it is actually easier to work on projects with short time-lines (6 weeks seems to be a good number). Urgency and a looming dead-line focuses the mind in wonderful ways.
  • As a tactical measure, simplify your pointing strategy. Pivotal Tracker offers many pointing “styles;” linear, quadratic, fibonacci, or you can customize your own. Try going simpler (instead of finer granularity); a 0-1-2-3 scale (easy, medium and hard), might give you a more accurate picture.

Reduce Scope

  • What’s really at risk if you miss the deadline? Often, the perceived urgency is far greater than the actual risk to the project.
  • Are there features that you can jettison?
  • Are there features that you can defer?
  • Are you spending too much time on “pixel-perfect fidelity?” Talk to your designers; look for ways to reduce complexity. One good way to reduce complexity is to lean more heavily on standard user interface libraries (which might affect the unique visual design of the project).
  • Can you make “soft releases” where you deliver fewer features, earlier, to reduce risk?
  • Look at your project goals again. Are the stories in the backlog truly delivering features that will meet your goals?
  • Are there parallel “tracks” that allow you to add man-power to the project (but see below).

Watch for Icebergs

  • Do you need to stand up a new production environment? That will take time. It’s a point-able story. Make sure that all the necessary steps to release are in the budget.
  • Are you refactoring as you go? Have you been postponing technical debt? Those interest payments will start to pile up as you get closer to release time. Make sure you and your team know that keeping the code clean is an essential part of every story.
  • Anything that changes your team will change both Volatility *and* Velocity. Are you adding a new team member? (Remember Brook’s Law, “adding manpower to a late software project makes it later.”) Vacations, holidays, sick days and babies will affect your velocity. Remember to account for it in Tracker.

You’re all clear, kid, now let’s blow this thing and go home!

This article should give you a lot to think about. Good project management is hard work. When projects are just getting started, everything feels fine, and later you start to wonder when everything went to hell. Remember, volatility kills.


Notes

velocity
Just like a speedometer that measures how fast you’re hurtling through space, Tracker’s velocity is a measurement of how fast your team completes stories. Instead of miles or kilometers per hour, Tracker expresses velocity as the number of points completed per iteration (normally a week).Because Tracker stories are assigned point values instead of due dates, Tracker calculates velocity by averaging the number of points you’ve completed over the past few iterations. In Tracker, past predicts future.
volatility
Mathematically, Volatility isStandard Deviation ÷ Mean Velocity
acceptance
If stories languish in the accept/reject state (a field of red and green buttons in the backlog is a strong indicator), several bad things may happen to your project: You lose the fast feedback loop between delivery and deployment. Developers will move on to the next story and may have already lost “context” about past ones. Unaccepted stories can not be deployed, so there’s less and later feedback about the feature in the full project.
stories
What makes a feature or a bug or a chore is worthy of an entire article on its own.
  • 0 Shares
  • Share on Facebook
  • Share on Twitter

Topics

  • agile (778)
  • rails (113)
  • testing (86)
  • ruby (83)
  • ruby on rails (70)
  • jobs (62)
  • javascript (54)
  • techtalk (44)
  • rspec (38)
  • activerecord (29)
  • productivity (29)
  • gogaruco (29)
  • ironblogger (29)
  • git (28)
  • nyc (27)
  • rubymine (25)
  • mobile (22)
  • bloggerdome (20)
  • cucumber (20)
  • process (19)
  • pivotal tracker (19)
  • jasmine (19)
  • design (18)
  • ios (18)
  • webos (17)
  • objective-c (17)
  • android (16)
  • palm (16)
  • "soft" ware (16)
  • fun (15)
  • tracker ecosystem (15)
  • ci (15)
  • cedar (15)
  • rails3 (14)
  • performance (14)
  • bdd (14)
  • gem (13)
  • selenium (12)
  • css (12)
  • goruco (12)
  • bundler (12)
  • tdd (12)
  • meetup (11)
  • railsconf (11)
  • nyc-standup (11)
  • capybara (10)
  • mac (10)
  • mojo (10)
  • chef (10)
  • rubygems (9)
Subscribe to Tracker Feed
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. ...
  9. 18
  10. →
  • About
  • Case Studies
  • Team
  • Community
  • Careers
  • Contact
  • Labs
  • Events

Contact Us

contact@pivotallabs.com
+1 415-77-PIVOT
TwitterLinkedInFacebook

Pivotal Tracker

Tracker is the award-winning agile project management tool that enables real-time collaboration around a shared, prioritized backlog.
Visit pivotaltracker.com >