The project process
Steps in the Project Process
A project is created when we conduct a discovery sprint to clarify business objectives, project goals, and user needs. We work closely as an integrated team (Producer, Designer, Engineer, QA, Client/Product Owner) to define the Project Brief.
Our Project Brief lists the details of who we are building for, what problem we are trying to solve, and why that problem matters. We establish what the smallest valuable Core Loop through the product looks like. That’s where we’ll start. The project might be an MVP web product, new mobile app, a digital marketing campaign, or a complete end-to-end digital transformation of existing business practices.
After setting up the Project Brief, we run our starter stories from a script. We don’t even have to think about all of our standard project setup tasks. This mostly automated sequence ensures that each project is set up in the same way and no part of the process is left up to chance.
The first 20 or 30 tasks involved in the setup of a new project used to take hours, or even a day, to complete. Now, the Slackbot script will perform these tasks in about 10 seconds:
- create the project in GitHub,
- add the Project Brief template,
- hook up the Agile tools,
- set a bunch of permissions,
- and generate the first batch of stories.
We invite clients to the Slack channel that we set up for that project so that the whole team sees the conversation and development as it unfolds. This full transparency is another area where Revelry differs from typical software and innovation companies.
Next up, we write the first round of user stories. In the upcoming sprints, these stories enable the team to design and implement that first Core Loop.
The project is broken down into feature requests and essential tasks by writing user stories, which are objectives a user should be able to achieve with the product. Each user story is further defined by acceptance criteria (AC), a checklist of requirements needed to complete the user story.
We develop and launch user stories during each one week sprint. We end the sprint by writing user stories and scoring them before the next sprint’s kickoff meeting. Sprint 2 stories are written in Sprint 1, Sprint 3 stories are written in Sprint 2, and so on.
Lean Agile User Stories at Revelry
We tell our clients that one of their most important jobs is to help us write user stories that capture their product vision. They are involved in this step and it’s a collaborative process where multiple people on the team will provide input and the business’s product owner signs off on the final story. Here’s how we write them:
+ Create a Quickly Digestible Title
If you’re an Agile fan, you’ll notice that our User Stories differ slightly. Typically, an Agile story headline would look like this: “As a [user type], I want to [perform some action] so that [I can receive some benefit].”
But we’ve adopted an alternative headline format:
“[User Type] – [Feature Bucket/Epic] – [Action or Result]”
We want our User Story headlines to be easier to scan across our project management tools. They should be consistent from story to story. And, we want our project tickets rely increasingly on communicating the business value within the body of the story, where it belongs.
Here are some examples.
- Typical Agile Headline: As a user, I want to sign in with my email address and password
- Lean Agile Headline: Registered User – Log In – Log In Via Email, Password
- Typical Agile Headline: As a developer, I need to setup my local environment
- Lean Agile Headline: Developer – Project Setup – Local Environment
- Typical Agile Headline: As a bot, I need to deploy the staging branch to Heroku through Codeship
- Lean Agile Headline: Bot – Continuous Deployment – Deploy Staging Branch
- Typical Agile Headline: As an admin, I would like to filter users by most recent sign in
- Lean Agile Headline: Admin – Reporting & Analytics – Filter Users by Recent Sign In
These stories become issues in GitHub with a unique identification number. We manage progress by using a Kanban board that automatically visualizes the status of your GitHub Issues.
+ Add Business Value as Background
We include business insights on our stories to help to clarify objectives. Many teams don’t do this, but it’s important at Revelry because it helps our developers and designers understand why they’re building a feature and how it’ll impact other pieces in the larger picture.
For example, if we write a story for a 3D-printing interface like our client Entrescan, we’d include a note about the broader business context. “Entrescan wants to open up 3D printing to people who are new at this and don’t have a printer at home. So, the interface needs to be really simple, and it has to work in a user’s browser without special plugins, to make it more accessible.”
+ Unambiguous Acceptance Criteria
All stories must have acceptance criteria (AC). Anyone on the team can define AC, but the Product Owner (client) must sign off on them. These AC go to the issue description on GitHub as checkboxes.
We write AC as Given, When, Then statements designed to describe specific user behaviors which accomplish business goals:
- GIVEN a specific state
- WHEN I do a specific thing
- THEN this specific things happens
For example the AC for the “Admin – Reporting & Analytics – Filter Users by Recent Sign In” story might be:
+ Add design sketches and screenshots
When possible, we also add screenshots or sketches of the desired outcome to add more context for developers and designers as they develop stories. Some companies leave this step out, but we think it’s important because visuals make it easy for our developers to be on the same page as our clients when it comes to their rationale for a story and how it’s connected to others.
Scoring user stories
Once stories are written and approved, we need to figure out how difficult and complex they are so we can prioritize our resources for the next sprint.
This happens during the story scoring process, which estimates the amount of effort we’ll put into each story relative to other stories. Team members cast their personal votes and then we calculate the average score for each story.
A democratic process like this can take awhile, and it wasn’t uncommon to spend 2 hours on a scoring meeting at Revelry, which ate a lot of developer hours.
So we automated it. Our meeting time dropped to 45 minutes or less.
We built a Slack bot, /poker, that prompts each team member for their vote on a story, calculates the average, and moves on to the next story. The bot hides story scores until everyone has cast their estimate, so we don’t influence one another’s answers, then uncovers them with a /poker reveal.
It’s essentially a virtual, automated polling system that cuts out over an hour of inefficiency. This really adds up when you use it every week for a team of 3-6 people. Plus, we’re all in the meeting at the same time, but we can be on opposite coasts or in different countries and have an equal hand in the quick meeting.
Then we queue up the new user stories (write them, define AC, score them, and put them into GitHub) in preparation for the first sprint. If Revelry joins up with a client’s team while a project is already in motion, then that team needs to have the stories written and scored before the first sprint with Revelry.
Sprint 1 begins with a Kickoff
1. Assign Team
We assign a full stack team of 3 to 6 Revelry teammates needed for that sprint: a mix of architect, developer, designers, quality assurance, product, and producer. We sometimes create developer/developer and developer/designer pairs and place them into existing teams.
One thing that’s unique about working with Revelry is that you have access to teammates who have deep industry specialties. You can bring on a finance tech expert who used to work at Capital One, or someone from IBM, or even load up on designers if your project is design-heavy. We build you a team that’s the best in the business for that sprint.
Another important teammate is the Product Owner: usually a point person on the client’s team who serves as the ultimate decision maker on everything related to the product. On most projects, the Product Owner co-writes the user stories with Revelry and is–as much as possible–involved in the day-to-day of the sprint. If the client can’t play the role of Product Owner, we provide that as a service, bringing fully written stories to the client for approval and user testing.
2. Revisit Stories
During kickoff, we revisit the stories we wrote and scored in the previous sprint, prioritize them, and make individual commitments to get ‘em done. We also make sure to:
- List dependencies and potential blockers in the story’s GitHub ticket as check boxes.
- Link up any stories that must be completed prior to work on an individual story using GitHub #issuenumber, which also calls out dependencies.
- Assign issues to teammates that we need answers or feedback from.
Sprint time – How we work stories
We use GitHub for distributed version control and story tracking, and we use kanban to visualize that progress (it connects to GitHub so it updates our stories automatically).
The story sits in the Backlog column until we move it to This Sprint during the sprint kickoff (when we form the commitment for the sprint). When an engineer starts working a story, they move it to In Progress. As they complete AC, they mark the check boxes.
Once all AC is complete, the code is scanned by Lintron, an automatic style checker we built. Lintron is a pull request robot that we update every time we create a new code standard, and it very consistently catches style and logic issues, freeing up human code reviewers to provide substantive feedback. The results have been great.
When an engineer has addressed Lintron’s notes, they move the story to In-Review and assign their pull request (PR) to a different engineer on the team (or in the company). Once the code is reviewed in-depth by a second Reveler, we deploy the story to internal QA. We use Codeship for automatic deployment and continuous integration, so any code that passes review is available for QA within minutes.
If QA finds an issue with any of the AC, they uncheck the box and send the story back to the engineer. In the case of a large story where just one AC is missed, we close the story and log a new bug. If an edge case arises in QA that isn’t represented by any AC, we log a bug. Once QA’s done we move it to user acceptance testing (UAT).
User acceptance testing (UAT)
One of our clients’ most important jobs, alongside helping us write user stories, is to do UAT and use the system every day. If there are issues, they send it back down the chain to engineers. Stories coming back from UAT are the highest priority so we work on them immediately. Getting time from our Product Owners (clients) is tough and when we have them in the mix, we make sure to address their concerns as fast as possible.
When the story’s complete in UAT, we immediately ship the new features to production through another automated deployment.
How we work Standups
Our daily standup meetings happen in Slack, and are complete in 10 minutes or less. We’ve seen many benefits: Slack is quicker than getting everyone on the phone, and managers can quickly skim through the notes on multiple projects to get their pulse.
We use the built-in Slack /reminder command to run our scrum meetings for us automatically. (Here’s a closer look at how we do it). It sends a reminder to the team to round everyone up and reinforce our scrum philosophy.
Each person on the team answers the following questions:
- What did you do yesterday? include issue number
- What are you planning today? include issue number
- How are you blocked? ask for help & set reminders
- We note blockers and take them offline to be addressed. Do not solve problems on standups.
- If we need to hash anything out face-to-face, we quickly jump on a zoom.us call.
All updates need to reference a specific issue number, and by the end of the meeting, we’ve updated all the stories to reflect their current status.
Lean Agile Sprint Wrap-up
During the week, we have also been writing new stories for the next sprint. Often we will run a session of planning poker at the end of the week to prepare for the next sprint kickoff.
Every other week, the team has a retrospective conversation. we discuss what felt crappy, what was awesome, and specific tactics to improve the next sprint’s communication or velocity.
Start Sprint 2
- QA & UAT
- Write and score stories for Sprint 3
Rinse & repeat.
That’s how we do it, folks.