Waching daily Jan 31 2019

(stirring music)

- Hey, I'm Shyamala.

Did you know that over the past two years,

the Meeting House community

has raised over $530,000 in Peace Cards

and put together over 2,700 Relief Kits

to assist families affected by unrest in Jordan and Syria?

Last year, we assembled over 1,000 Relief Kits

specifically for families affected by the Syrian crisis.

These kits provide simple items and meet basic needs

to those who have suffered tremendously.

We also gave over $260,000 in Peace Cards last year,

which was used to support programs such as

Emergency Preparedness and Response Teams,

Jos Peace Institute,

and Circle of Support and Accountability,

and Youth H20 Project in Ontario.

These Peace Cards and Relief Kits are an important way

for us to take action and show love and compassion

to some of the most vulnerable people in the world.

And now, it's time for this year's Peacemakers campaign.

Our goal this year is to raise $260,000 in Peace Cards

and assemble 1,000 Relief Kits.

But even more importantly than that,

we want our community to invest in these stories

that we have the opportunity and privilege to be a part of.

Take the time to learn and talk about

the stories and the people that we get to love

through this campaign.

It's not just about the money,

this is our chance to love the most vulnerable in this world

and to actually see lives transformed.

Through Peacemakers we have the privilege

to partner with God in the restorative vision

that he has for all creation.

(inspiring music)

For more infomation >> Peacemakers 2019 | Launch Video - Duration: 2:14.

-------------------------------------------

My first Gacha video! - Duration: 0:09.

For more infomation >> My first Gacha video! - Duration: 0:09.

-------------------------------------------

How to Track Projects Effectively | Video Course | TeamGantt - Duration: 21:37.

(lively music)

- Hi and welcome back to the Art & Science

of Leading Projects.

Today, I'm going to talk to you about project requirements.

It's a term that haunts me still

because of a bad experience I had

with really poorly written and poorly tracked requirements.

They're a part of a project I inherited

very early in my career.

I'll spare you the details, but basically,

they were half written, the project was about 90% complete,

and the stakeholders started asking where some things were

and why what was there was not working

as they had expected.

I had to jump in and figure it out.

So I resurrected the requirements document,

discussed them with the stakeholders,

and recorded a whole new set of priorities.

We used that to discuss an increase

in scope and timing.

But just taking that step back

saved me a lot of stress and confusion.

My situation isn't uncommon.

Very often, projects fail due to poorly managed requirements

or even a lack of requirements.

I'm not sure if that's because people are scared

to ask questions of one another on projects

or if they just don't think to do it.

I do know that if your project is complex

or if it changes often

or even if your team and stakeholders

are not great communicators,

working without requirements

will definitely be painful.

Okay, so if you're new to this,

you might be wondering what requirements actually are.

So thanks for hanging on.

And let me explain.

A requirement is a document or a statement

that defines what must be achieved or created

on a project.

They're often also referred to as use cases,

features, or even functional requirements.

It essentially defines an overall goal

of what a product must do,

what it should look like,

and how it should function.

I've mostly seen requirements to find

as detailed text in a spreadsheet

or as annotations on a design or schematic.

But you might decide to look at them

in a different way.

Essentially, the goal is to make sure

you're able to communicate the information

the team needs to design,

build, and test a product.

Or even just a piece of it.

Requirements are also great for setting expectations

with clients or stakeholders

to make sure they're clear on what they're going to get.

In that respect, it makes it easy to decide

if something is complete or not.

Plus, if a stakeholder decided to add a feature or requests

and change the project,

you can refer to your scope and requirements

to make a decision about priority

or if scope increases are needed.

Requirements in whatever form they take

are really essential to building a product or service,

because they help set expectations

and align teams and stakeholders.

Without them, there's a strong chance

that you could produce an incomplete or defective product.

Or worse, one that your stakeholders won't accept at all.

So while they take some time to produce,

it will be well worth your time spent

gathering and managing them.

That said, not all teams document and manage requirements,

and that's okay.

As long as you're comfortable with managing

the details on your project

without having them documented.

Afterall, not all projects are complex

and not all project leaders feel the need

to document and manage requirements.

If your team is agile and your projects

are fairly loose,

you'll be fine without documented requirements.

Chances are, you're using stories or epics.

And those are pretty much the same thing as requirements.

But if you're dealing with complex projects

with large scopes and budgets

along with tight deadlines,

you might wanna think about how requirements can help you.

Alright, are you sold on the need for requirements yet?

Let's talk about how you can document

and manage requirements in four steps.

Gathering and documenting,

alignment, tracking and managing change,

and confirming.

Let's dig in.

The first step is gathering and documenting requirements.

And that's a fancy way of saying,

how the heck are we gonna figure out

exactly what we're supposed to be doing here?

But before I get into the process

of gathering and documenting,

I think it's important to talk about

what a good requirement looks like.

First and foremost, a good requirement

should be valuable and actionable.

That means that while it should define the goal or need,

it should also detail how you'll meet that goal.

Also, it should be written in plain language

so everyone involved can actually understand what it means.

Like I said earlier, a format in language

may vary by team.

It can be sketches of what's intended.

They can be structured in statements

that say what it should do.

They can also be high level requirements

that state an overall goal and have sub requirements

with hyper specific detail that rolls up to them.

You'll probably start high level

then dig deeper as you get into the work.

And that's a good way of approaching requirements.

Because what you know about the project

will evolve over time

as the team works through each goal.

And you'll get to a level of detail

that will help your team to execute

on each requirement accurately.

At a high level, it's important for a member

that good requirements need to be concise and specific

and simply explain what's needed.

Okay, now let's talk about how to figure out

what those requirements actually are.

Well, it's gotta start with a statement

about the project goals,

and what exactly the business and its stakeholders

expect the final product to do.

So you have to get some pretty high level info first

and start digging.

Sounds easy, but it can be a little bit like pulling teeth.

It's important to remember that not all stakeholders

think like you do in terms of features,

functionality and time to build.

In fact, it could be a big black box for them.

So this is your chance to connect their business goals

and requirements to your project.

The best way to understand what your stakeholders

actually want is to ask questions.

If you watched class three on estimating,

you know that I'm not afraid of asking a bunch of questions

to make sure I can be as accurate as possible.

You shouldn't be afraid of asking questions either,

especially if it will help you to gain clarity

with your requirements.

Here's the thing.

You can't necessarily take a cookie cutter approach

to every project.

Sure, you may have some core questions to use,

but before you dump a set of questions

on your stakeholders, be sure you understand

what you're asking and why.

It maybe helpful to ask yourself some questions

about what exists already

in terms of supporting documentation

in your stakeholders.

If you're not sure you're thinking

about this in the right way,

check out the pre-requirements question download,

as well as the sample requirements checklist,

which is a real template I've used

on web design projects in the past.

My hope is that those documents

will give you an example of how you might start

to organize your thoughts

and draw out the needs of any project.

It's really about being thorough.

The answers to your questions will eventually turn

into expected interactions,

features, or functionalities

that will help you to begin your requirements documentation.

So set yourself up for future alterations

of your document by formatting these responses

in a readable, shareable format.

This will set the expectation

of what goals the project will meet

and how what you will deliver will map back to those goals.

The best way to document these requirements

is in a spreadsheet or a list that works for your team.

Essentially, what you must document are:

requirement name and number,

which is a unique name that describes

what is being discussed

and can be easily referred to.

You'll want to number these in case you have a lot of them.

So you can easily find them in your document.

Second is a requirement description,

which is a simple statement that defines

the business need the requirement fulfills.

Then there's the category which is a group identifier

for similar requirements that all project resources

will understand.

This could be the section in your sitemap,

a part of your product, a technology,

or whatever other category

that makes sense to you and your team.

Last is notes, which is a place to capture questions

you have for your stakeholders

that will surface as a requirement evolves.

As soon as you've documented

the high level of a business requirements,

you're ready to compile the questions you need to ask

to get into the true details.

Start broad with a top level question about functionality

and use the response to dig deeper.

Here's an example with followup questions

that could arise.

Will your site require users to log in?

Does registration require payment?

Will the site display a logged-in user's name?

First and last name, or just the username?

Where's login information stored currently?

Will it stay there?

Do logged-in users have access to information

or functionality that non-logged-in users have?

What happens if someone forgets a password?

Do you have error states currently designed

into the system?

As you can see, there's several questions

that could come out of one single response.

And each response could add requirements to your work.

That means that one simple yes or no answer

could have scope or budget implications attached to it.

Therefore, the exercise is really important

in understanding what your team can do within your scope.

And that's why a requirements checklist,

similar to the example download,

can be really helpful.

As soon as you've determined all answers

related to a piece of functionality,

add it to your requirements doc.

Arguably, this step in the process

will take a lot of time.

But again, it can be worth that time spent

if it helps you to avoid issues with scope creep

and even communications.

Alright, let's move on to step two - alignment.

This is the step that feels like it could take an hour

but can last weeks if you don't handle it well.

There's no playbook for how to gain

alignment on requirements,

because it really depends on the size

and intensity of your project

and how you engage with your stakeholders.

My suggestion is to gain consensus on high level goals

and requirements

and leave the detail to the team.

But that requires a lot of trust

between the stakeholder team and the project team.

If your stakeholders wanna be in the weeds,

plan for some additional time

to discuss, document, and revise the requirements.

But mostly, what you want here

is buy in on approach, your overall approach

on what's included.

This is gonna help you to better plan your project,

control your scope, and say,

sorry, we can't add that new request

without looking at our requirements and scope

to see where it fits.

And that sounds pretty powerful to me.

So let's move on to step three,

which is tracking and managing.

Okay, so this isn't really a step

as much as a reminder to stay updated.

Projects get busy and we forget about this kind of stuff.

But if you're not keeping all

of your documentation up to date,

there's really a good chance that you'll forget a detail

and it will come back to get you.

We all know that projects change.

That doesn't always mean it changed your requirements,

but keep it in mind when new requests pop up.

So make the time to get all of your administrative work in

while you're doing everything else on projects.

When you think about it,

the really cool part about requirements

is that when you manage them through a project,

you get to see something that started as an idea,

a discussion about goals, and then that being formalized

into writing, and taking it something that's designed,

built, tested, and functioning in the world

just the way it was intended to be.

If you truly wanna do a good job with that,

you'll take copious notes

and update them in your requirements documentation.

And that brings me back to format.

There are a lot of great ticketing systems out there

that can help you manage your requirements.

You can also use TeamGantt to help communicate requirements

and even record changes over time.

So you have to know that things are going to change

with your projects.

And you have to expect it and adapt to it.

And one more time, you have to document those changes.

Alright, the last step is confirming.

If you nailed your requirements and kept them updated,

chances are, you'll nail QA and release.

That's because when you take ideas

and get specific about them,

you leave less room for error

or even misinterpretation.

And that makes the quality assurance process easy too.

So there are a few different ways you can close

or complete requirements.

And the process for it will depend on how you like to work.

First, like I mentioned earlier,

you can use TeamGantt to document

and track requirements.

In fact, our development at TeamGantt

uses notes and discussions to track requirements

through their sprint process.

I recruited one of TeamGantt's founders,

John Correlli, to walk through how it's done.

Check it out.

- [John] How you handle technical requirements

is crucial to how efficient your team performs.

Too little information

and they'll spend their time trying to gather

the missing requirements.

Too verbose and your team will have to sort

through the details to pull out the information

that's important to them.

Each team is different.

And it's up to you to find a sweet spot

for you and your team.

Today, I'll show you two examples of how we're managing

requirements within the dev team here at TeamGantt.

The first will cover new features,

and the second will be for a bug fix.

However, before we jump into these specific tasks,

I like to say we have a pretty simple

and straightforward approach.

Requirements go in the Note section on a task

and any additional discussion

revolving around the task

goes into the discussion area below.

We're also leveraging markdown

anywhere we can to increase the readability.

We'll use our Slack integration for this first example.

In this task, we're adding the ability

to list your active projects

regardless of where you are in Slack.

When it comes to requirements,

I like to cover what is happening,

then drill into how.

As you can see here, we wanna allow the user

to type in a command and list their projects.

We also want them to be able to add a search term

and narrow the project list.

Once we've established what is going to happen,

we'll talk about how we get there.

In this case, we want the user to enter the command

/tg projects

with an optional search term.

We want this response to be private

so that only the user making the request

sees the response.

We wanna make sure only active projects are returned.

If a project is starred,

we wanna make sure it's indicted.

And finally, we cover how to make the request.

As for bugs, we handle them a little bit differently.

Here's an issue Aaron reported from a while back.

Within our bug's project, he created a task

called +Not Working when project is open.

Within the Notes field,

the steps to reproduce the issue were added

along with the expected and actual results.

Aaron also provided a screenshot

with additional information.

It's always helpful when you can get a screenshot

or screen capture with your bug tickets.

In this specific case, our steps to reproduce

are very simple.

Open any project, ensure the sidebar is expanded,

and click the plus button next

to the active projects setting.

We're expected to be taking to the Create Project screen.

However, as you can see, nothing actually happened.

We were quick to jump on this

and had to fix out a few hours later.

Once it was live, we used a discussion area

and let Aaron know.

And that's pretty much it.

Managing your technical requirements

doesn't have to be hard.

Like most people, we found it best to write things down

into small chunks, but without overdoing it.

I hope this helps you

as you take your projects from an idea to a success.

- So, while using TeamGantt is a great solution,

as with anything else, there are many ways

to track requirements.

I tend to like to use ticketing systems

during the QA process so I can track those requirements

and work being done against them

through an acceptance and then eventually launch.

The process around that would generally be

that I would initiate a ticket

that would keep past down the line

during the project process,

and it would end with QA to test.

If QA finds an issue, they record it

and assign the ticket back to me.

If they don't, they mark it as complete

and assign it back to me.

As the lead, I close the tickets to ensure completeness.

I've also used spreadsheets to track to completion,

and essentially would move a row to another tab

or just color code requirements when they're complete.

You can handle this anyway you like, really.

The point is just that you have to track

what is complete before you release your product.

In fact, there are plenty ways of handling requirements.

We asked our PM experts for some tips

on documenting requirements.

Let's hear what they had to say.

- Documentation is crazy important.

We live by the rule, and my team is

if we haven't documented it, it doesn't exist.

And so, I think documentation is very crucial for teams.

I don't think we have to document every single

little thing we do,

but I think meetings notes are key,

open questions to the group are always key to document,

and then obviously some of the larger things,

like timelines, artifacts,

things that we're doing.

I'm not necessarily set on any one tool.

But as long as there is one that everyone uses

and understands, so there's a shared place,

a common place for everyone to go to

to be able to see and dig

and find any bit of information they maybe missing

as they go through the projects,

I think that helps the project just run so much smoother

as opposed to having to send out another email,

Slack another person and trying to figure out

where that one document is

or that one screen is or that one meeting summary is.

If we have it in that one kind of shared common place,

then I find it makes the process so much easier.

And our teams feel more well-equipped.

They can go into their meetings feeling confident

if they have all the information that they needed.

- I think the first thing we think about

when it comes to gathering requirements is

like the tools or the techniques we use.

I really don't think that matters at all,

what those are.

I think the most important thing is that

you're doing it in a sort of open environment,

you're doing it in conjunction with the client

or your stakeholders.

And that's a collaborative thing.

You're doing it together.

And that is not just something that happens

at the beginning of a project,

but rather, something that lives throughout

the course of the project.

If it has to change, you change it openly with your client.

And you make those as you through the project.

- Again, I think thinking about

the audience that you're communicating

those requirements to,

so the way that a developer needs to

internalize and understand requirements

may be different than the way your client needs

to internalize and understand those requirements.

So really thinking about what are the ways

in which you are creating

a shared understanding of something

but also being aware of the different needs of the audience

is that you're trying to serve with those requirements.

I think often, we write requirements

in a way that make sense to us

and our clients don't clearly understand them.

And then that means they don't really understand

what it is that they're buying.

So really making sure that you're tailoring

what your communicating so that everybody agrees.

Yep, this is what we're building.

This is how we know we're successful.

- I think it's really helpful to actually

sit down and workshop it.

So don't just talk about what you have to do

and then write it down

but work through it together.

Use that time to visualize what you're trying to make,

try to use that to maybe develop early flows or ideas.

You can start tracking like, again,

the pieces that you might miss.

Sometimes you can do that by working backwards

from a launch idea.

So if you're gonna launch a version

or iteration of a product,

think about what needs to happen in reverse

and you can actually come up with some interesting

new ways of solving it.

I also would recommend

that teams use 90th percent confidence

when they are setting up their requirements.

So what that means is that we would sit down

and try to find out what like the minimums

to the maximums in terms of complexity and effort would be

and that will help us actually frame the project

in a way we're really comfortable with

what we're creating in terms of outputs.

- I'm a real fan of writing down direct quotes,

because sometimes, they're able to capture

what somebody means

without trying to wrap it up

in some kind of technical jargon.

Another tip I have is to document everything

and take care of future you.

That's something I learned from a friend of mine,

Katy, back in the UK.

Taking care of future you

means writing things down and not relying on,

oh yeah, we'll remember what we meant by that.

That's fine.

You probably won't.

Just write it down, and that's my tips

for documenting requirements.

- When documenting project requirements,

make sure you're constantly asking the question why,

how, where, when.

Asking those questions will ensure

that you know exactly what needs

to go into the requirements.

When you're also putting together requirements,

make sure that you're covering all different avenues

that are important.

It's not just understanding the technical side

of how things need to go,

but it's also understanding the business rules

and requirements around that

and understanding how it's going to impact the end user.

Also getting in feedback from your QA team

and making sure that they validated how you can go through

and do acceptance criteria

and tracking all that information is extremely important.

We use different tools in order to make sure

everything is documented so that you have clear access

for everyone that's a part of your team,

whether you're all working in the same office

or you're working remotely.

Making your documentation easy access for everyone

where they also have the ability to continue to edit

as requirements change,

make sure that you're not missing anything.

- That brings us to the end of the class.

I hope it inspires you to take a look

at the downloads and think about

your own requirements practice and process.

There's more than one way of doing this,

and it's up to you to find the right way.

So come back for class five,

which will be all about project planning.

(lively music)

For more infomation >> How to Track Projects Effectively | Video Course | TeamGantt - Duration: 21:37.

-------------------------------------------

RCA - "SelectaVision Video Monitor" (Commercial - 1983) - Duration: 0:33.

For more infomation >> RCA - "SelectaVision Video Monitor" (Commercial - 1983) - Duration: 0:33.

-------------------------------------------

Project Estimation & Budgeting | Video Course | TeamGantt - Duration: 38:46.

(upbeat music)

- Hi and welcome back to The Art

and Science of Leading Projects.

I have a question for you, how long is it

going to take this painter to finish this job?

And how much do you think it will cost?

Hmm, not so easy to answer, huh,

probably because you have a lot

of questions and that's a good thing.

You should never just throw numbers

out there, unless you're on a game show.

And when you're working on projects,

you're gonna want to take a more measured

approach to creating estimates.

Lucky you, that's what this class is all about.

So, let's dig in.

(drumbeat)

So, what is estimation?

First, I want you to know that I understand

estimating projects is not easy for a number of reasons.

Teams and talent differ on projects,

our approaches to projects change,

sometimes we're not given enough info

to create good estimates, the list can go on.

But before you say forget it, you have to understand

what an estimate is and why you should do them.

A big reason it's not easy is because by definition

an estimate is an approximate calculation

or judgment of a value, number,

quantity or extent of something.

It's just a rough guess, but for some reason

people tend to think estimates are carved in stone.

They never should be, they're not exact.

They're guesses for what it could take

to get something done.

That often makes people ask the question,

if our estimates are never exact, then why bother,

and I get that, but there are a lot of good reasons

to create estimates, even for those people

who just want to start working or just don't

value the idea of an estimate.

The thing is, if you do not value estimates,

you probably don't try to create them accurately.

And if you're a project lead, you might need

some powerful and specific reasons to create estimates.

Here are just a few.

The first question a solid estimate can

answer is, is the project worth it.

Estimates help calculate a rough determination

of cost which can help decide whether or not

the project is worth the investment.

So, whether you're on a client side

or an internal team, you want to know

if the effort or cost matches the potential outcome.

For instance, I'm not going to build

an app for my company if it costs a lot of money

and I won't see a solid return on that investment.

The next question an estimate can help answer is,

do we have the staff to complete this project.

A good estimate will be based on specific tasks

and the talent used to complete them.

So, estimating with staff or even talents required

in mind will help you to staff the project properly.

Honestly, just exploring what something might be

can help you determine if you have the right people

on staff or if those people are even available

and if you really need to do the project,

it'll make you find those people

before you urgently need them.

If you're lucky, they'll help you

to estimate their time as well.

And then there's the question, how much time do we have.

You'll probably be wondering about the time

needed to complete a project, especially if you're taking

on something that you've never done before.

So, asking the simple question,

can we get a sense for how much time

this will take, is going to help you.

You always want a sense for how long

something will take to complete so you can

set the right expectations about deadlines.

But it's also important to consider

that more complex projects can be dependent

on other projects or tasks.

Knowing just how long it will take to complete

your project might answer an important question

about another project and when it may have

to start or finish.

Better yet, if you want to build something

for an in-person event or an announcement,

will you have enough time to get that done?

If not, you might have to think of alternative

approaches or ideas, but when you create

solid time estimates, which we'll cover in this class,

you can make some pretty direct assumptions

about overall timing, and that's powerful.

The last question is one that not all teams

have the luxury of asking, but it can be

important to team morale and even productivity,

and the question is, are we excited about the project?

You've gotta have your team's investment

in the project in order for it to be a success.

Because working with a team can often be

a challenge, particularly when no one has agreement

on working on a project, working together to produce

an estimate can be a great way to pull

the team together to ask about staffing,

responsibilities, process and even timing.

It might also be a good time to do a gut check

about how interested everyone is in approaching it.

So, those are some simple questions you can

answer by creating an estimate and even help you

to make the case for why you should create estimates.

But the questions won't end there.

When you get into estimating, you'll ask

some project specific questions that will help

you to shape your estimate and project scope,

but first, you want to gain a high level

understanding of these things.

Your industry, trends, changes and innovation.

It's important for project leaders to have

a current and ongoing view of what's happening

in their respective industries because our projects

often come to us as a result of a trend or a change.

Projects are also sometimes an opportunity

to try something new, so, making yourself

aware of innovation or big changes

on the horizon will help you to understand

possibly what's ahead of you in a new project.

That might not always help you

with an actual estimate, but it'll give you

an opportunity to ask even more questions

and figure out what might be coming to you.

An example of this for me was back

in 2009 when responsive design

became the next best thing in web design.

We had to figure out how to estimate for it.

That caused a lot of questions and changes

to the way presented work, gained approvals

and even the way we talked about what we did.

And that certainly affected our project estimates

because we put more time in the process.

Later that changed because we found efficiencies,

but having the opportunity to explore

the process and create estimates with the team

was so helpful because if we had not done that,

we would have lost a ton of money.

Next is your team and their capabilities.

You cannot forget to consider your team.

After all, you're collective team will

make the work on the project happen

and because not everyone works

on the same level, you'll want to consider that.

On some level, you should have an understanding

of what your team members are capable of doing

and even where they might need some help.

It's all about understanding capabilities

and expertise because when you know that,

you'll be able to create more solid estimates

based on who might be assigned to the project.

Next is process, process will play

a pretty big role in how you create estimates.

Chances are you have some general guidelines

for how your team handles process.

If you don't, check out class number two,

and tighten your process so you can consider

how you'll do things when you're estimating.

I also just want to note that process can evolve,

especially if you're using a hybrid method.

So do everything you can to be consistent

about conducting and documenting retrospective meetings.

That way you can continue to learn about

what's working and what isn't and create

fair estimates to improve upon those things.

And be sure to check in on projects,

and understand the complexities of what you

do well, and what you struggle with.

If you keep a log of work you've done

and your experiences, or better yet, retrospectives

and notes, or even time logs, you'll find a lot

of detail to help you get better estimates.

And that leads me to my last point here,

history on similar projects.

When you're estimating a project,

and you're just not sure how long

something should take, look back

at similar projects to see how they were handled.

That could include looking at plans

for timing or even hours logged in a time

tracking system to find actual time spent.

Just knowing how something worked

in the past will help provide context

for how you might approach a new project.

It might not be apples to apples,

but it'll help you to ballpark an estimate.

So those are things you should keep in mind

when estimating every project, but there are

some more specific questions you can

and should ask when estimating a new project.

At this point, it's all about drawing out

the important details on a project

so you can think critically about what the project

will be and how you'll actually shape it.

You want to ask a wide range of questions

on topics from goals to budgets, requirements and more.

Grab the estimating questions download,

and work them into your own estimating process.

It'll help you to start an important dialogue

about project details before you actually start

working on a project, and that will

help you to create more accurate estimates.

If you come up with additional questions,

mention them in the comments below.

And I want to make one more point

before we move on to tactics.

While you might know the answers to all

of the questions I mentioned earlier,

it's a good practice to keep them in your back pocket.

Just simply asking some smart questions

shows that you're taking a considered approach

to creating an estimate, and that shows

that you care about how your projects work.

Optics are pretty big in project leadership,

mostly because no one can actually see good leadership.

So make it a point to speak up and share info

or ask questions when you can.

It'll make you look really good,

and it'll also make people trust you,

and you'll need that trust when you get

to the inevitable tricky project situation.

(drumbeat)

Okay, let's jump into some estimating tactics,

but before I share the tactics, I want to mention

that it's not just about the project leader

sitting at his or her desk coming up

with numbers based on what they know.

Working in a vacuum like that will

likely be counter-productive, especially if there

are parts to the project you're just not truly sure about.

I know that when it comes to web projects,

I know enough to make me dangerous.

And that means I don't know enough about code

to sit down and create an estimate for a developer,

and that's fair because I'm not a developer.

So, I prefer to make estimation

a collaborative team process, that way I get

the input of the people who'll be working

on the project, or the people who can

represent them and their tasks.

I've found that estimating in teams brings up

more and sometimes better questions, and new approaches,

quality discussion on process and collaboration

and ultimately more accurate estimates.

So, if you can work with a team to estimate, try it.

If not, use the questions I've shared

to dig deeper on the info you need and use

the tactics I'm about to present to create

your own estimates, but maybe get a second person

to do a gut check on what you come up with.

Okay, so first you should talk about the project

with your team before you start throwing out numbers.

Yes, that means more discussion and it'll build

on the things you've asked stakeholders.

It's necessary.

If you're thinking you're spending too much time

about the estimate, then scale it back.

But if you want to be really thorough,

talk about these things with your estimating team.

First, dissect the project goal, issue or feature.

This is an important question to agree

on as a team and you'll notice

that I've added issue or feature here.

That's because you can use these

estimating tactics when a new idea, requirement,

or even a bit of scope is added to your project.

Sometimes requests come in small bites

and you have to address them as one-offs.

No matter what, you want to make sure you truly understand

what it is you're actually designing or building.

Also, understand the intent, what should it do and why.

If you have requirements, great.

If you don't, start thinking about what

they might be and discuss them with your team

and your stakeholders so you can get pretty clear

about what will be included in your scope and your estimate.

Essentially, you have to get granular

on the what and why so you can figure out the how.

Next, discuss goals; every project has a goal.

If you identify it early on, you can use it

as your way-finding tool to not only help formulate

your scope, but to avoid the inevitable scope creep,

then discuss timelines and resources needed.

A project deadline can create immediate constraints

on process, deliverables and sometimes even budgets.

So make sure everyone is aware of that constraint.

If you keep your team's availability

and experience and expertise level in mind,

and look at that through the lens of a budget,

you'll be able to decide who is best-suited for the project.

Finally, consider stakeholders and partners.

You always have to consider who you're working with.

As a project manager, I can tell you that not

all clients or stakeholders are created equally.

Some folks get it and are easy to work with,

others need more attention.

Diagnosing that early can tell me how much time

I'll need to spend with them, and that will

definitely impact my estimate.

But also think about how large your stakeholder team is.

Will they require a lot of education and meetings?

Do they work with other partners

who will have a role in the project?

That's going to take time too.

It's easy to only estimate the tasks,

but remember to consider the amount of time

you spend in meetings, in slack, in email,

in TeamGantt, on the phone or any other

mode of communication you use.

So, those are all good discussions points.

You might ask, what is the best way

to have those discussions.

I always recommend that teams estimate together

and discuss how and why they're coming up with estimates.

Simply talking about the variables that contribute

to how you're thinking about an estimate

will spark ideas about process, pricing,

collaboration, deliverables, and so much more.

So if you work with a team, and get

into a room to talk it out, you should.

Okay, now that you're armed with the info

you need to make some real decisions based

on actual facts, you're ready to create

the most realistic estimate possible.

I've got this traditional project management

method in my toolkit and I use it all the time,

not only at work, but with home projects as well.

A work breakdown structure is a method

by which you can visually represent

the composition of project by breaking

down all project stages and aspects

into their smallest possible components.

So essentially, this method makes you think

critically about all of the tasks

and subtasks that make up your project.

Here's an example of a traditional work breakdown structure.

As you can tell, it's for a birthday party.

You know, project management seeps into our daily lives.

Just think about all of the projects

you take on in your life, everything

from planning dinners, vacation,

home projects, the list is never-ending.

And you can use the fundamentals

of what you learn in this class to help

manage your own personal projects as well.

So, this work breakdown structure shows

the project broken into four groups of tasks,

guests, location, caterer, and decorations.

Within each there are subtasks to explain

all of the work that needs to be done for each.

Your work breakdown for a similar project

or event might not be the same as this one,

and that's okay; we all work differently.

And that's why listing out steps can be

really valuable to talk about process,

timing and of course, estimates.

You'll also notice that there are no estimates

related to the tasks in this work breakdown

structure, and we want more info than that.

That's why I've adapted it a bit.

So, to me, because I have a background in web design,

this format kinda looks like a sitemap.

That makes it somewhat confusing to read,

and because it's missing the actual estimate

in numbers, it requires a little bit more work.

So I've extended the work breakdown structure

a bit, and I like lists, so my format's

a little different, but easier for me

and my teams to read and edit.

Here's a work breakdown structure

I created for my own personal projects.

Well, this is a design version of what I created

which was actually scribbled on a piece of paper

you'd probably never be able to read on screen.

I moved recently and wanted to get a sense

for how long it might take and how much time

my wife and I would need to devote to the project.

I have to say this was an estimate,

and not even close to reality, but that's okay

because estimates are guesses, and I learned

from it, and I'll do better next time we move.

Check out how I broke it down.

First, I listed the high level groups

as tasks, searching for a new home,

buying a new home, and moving.

Under each group, I've added tasks as well as

possible durations for each with a total of days needed.

Side note here, when estimating projects,

you can use any time value you'd like.

I tend to use hours on work-related projects

and days for home projects.

To me, estimating hours is more difficult,

but it will get you a more accurate

and specific estimate that you can benchmark,

especially if you're tracking time against tasks.

One place where I screwed up with this was in moving.

I have pack boxes at five days,

and in reality it took us about seven days.

And then move was a huge miss as well,

because while we took two days to do that,

it took about a month to truly settle in and know

where everything was, but again, that's okay.

I was ahead of the game just having a general estimate here.

What it comes down to is that you have

to break every larger task down into subtasks

to truly understand the level of effort,

and sometimes it's really helpful to get

really granular by breaking a task into subtasks.

For instance, if I'm writing an article,

I break that work down into smaller tasks,

like outlining, drafting content,

thinking about and requesting or creating images,

editing, delivering for review,

gathering feedback, editing and revisions,

proofreading, formatting and presenting.

Getting at that level of detail just makes

it easier to translate things that might seem

big and unmanageable into small,

manageable and sizeable tasks.

You should try it on your own.

Download the work breakdown structure homework

download and create your own estimate.

Feel free to post an image of your work

breakdown structure in the comments,

and I might check it out and reply.

So you may be thinking a work breakdown structure

is great, but I need an easy way of calculating

a project estimate in conjunction with an actual plan

and resources, how can I do that.

TeamGantt can definitely help you,

and I'll show you how now.

Okay, let's talk about estimating at TeamGantt.

So, first I'm gonna build out my plan in TeamGantt

to show all of the steps and tasks

that will be needed to complete the project.

As you can tell here, I'm starting with a pre-made plan.

If you want more guidance on how

to create plans, check out class number five,

or even some of the awesome resources

that we have on the TeamGantt website.

I do want to mention that you'll need to be

on an advanced plan in order to estimate by hours.

So you're gonna need to do that before you can do

anything that I'm showing you on this quick demo.

Then, you want to be sure that you've added your team

to the plan, so let me show you how you can do that.

So, you can use, it's a couple ways that you can do this.

You can invite people here, or you can

go over to the people tab.

I'm gonna show you how to invite people

through this functionality right here.

So, it's gonna bring me over to essentially

the same place where it's gonna show me

who's already a part of my project.

So as you can see, I've already added

Jason, Mara and Tim to the project.

They're all people who are on my team who have accounts.

I can also invite people by email.

I can add people just based on showing who is

in the account already, or I can add a new person here.

Right, okay, so I already had everyone in the plan.

So we are ready to go.

I'm gonna pop back over to the Gantt view.

Alright, so, let's see, back to where we need to be.

I've got all of my tasks in.

I want to go in and add estimated hours,

but before I do that, I want to check

my project to make sure the settings are

set up to actually have hours enabled.

So I'm gonna go into menu, and then I'm gonna

go to project settings; in project settings

you can see that there are a bunch of settings here.

The one that I'm focused on for this demo is enabled hours.

So I want to make sure that that's set to yes

so that I can actually add hours to this.

So, it's set to yes, and we are all set.

Alright, so, what am I gonna do?

I've got all of my tasks in, I've got all of my people in.

I'm basically ready to go in and add my estimates.

So you might have your estimate on a spreadsheet

or some other paper that tells you how much time

you should be spending on things.

So basically what I'm gonna do is go

to the first task which is conduct stakeholder interviews,

and I'm gonna click on this little button here

to the right of the bar on the Gantt chart that says

assign task and on that I'm gonna add myself to that.

I'm gonna be the person who's doing that,

and you can see that it's showing three days

on the Gantt chart, and I know that it was

hours estimated for this was 15.

So I'm gonna say I have about five hours

per day to get this task done.

You can see I accidentally just clicked

on Jason, I'm just gonna check him off,

but if I do click on him again,

I'm able to add his hours there.

So all I have to do is click done.

I've got 15 hours set up for myself.

You can see it sets it up in the bar in the Gantt chart

at five hours per day, 15 hours total.

In my estimated hours column it's showing 15 hours.

Super simple to do that.

So what I would do is go through all of my tasks

and make sure that I am assigning the proper people

to do the work at the right amount of time,

and it's going to keep adding my hours to my estimate.

Estimated hours will keep tallying up

at the top of each section.

If I go in here and add some hours,

let's say we give Jason three hours here,

you can see it's gonna show 12 hours

because it's over four days, 12 hours added

to that estimate, and then also it adds

to the larger estimate at the top of the Gantt chart.

So, then when you're done, you can

even open this availability tab.

You can see I'm down here at the bottom right.

Open the availability tab to see the hours

that have been assigned to people across days.

This is gonna be really helpful if you want

to do some workload planning within TeamGantt,

which isn't really a part of our estimating project,

but I wanted to let you know that, oh sorry,

estimating class, but I wanted to let you know

that that is something that you can do.

It's pretty simple.

So, what I want you to do after the class is

to check out the homework assignments

for step-by-step instructions and actually do an exercise

to get yourself comfortable with estimating in TeamGantt.

Okay, let's get back to the class.

As you can tell, you could do your whole work

breakdown structure in TeamGantt, and then turn

it into a plan by adding dates and dependencies.

TeamGantt's a huge help when you want to create

an estimate for a project that you've gotta

plan for or even just to come up with a quick

hypothesis of what something could be.

Remember, starting a discussion

about a project with a team and stakeholders

will likely yield a better result

than just finalizing an approach on your own.

So make sure you share that plan

with your team and make updates as needed.

But what about those times when there's

just an idea for a project and you don't have a plan?

Download the estimating Excel spreadsheet

to help you list your groups and tasks

along with your team members and to assign

total time and even a cost to a project.

You can edit the doc to fit your needs,

adjust the formulas and find a quick way

to create estimates on a large project

without skipping over major tasks or deliverables.

I've also used this in Google sheets

and it works really well when you're

collaborating with a team on an estimate.

On that note, you might want to think through

a good process for estimating projects with teams.

Here's what I've found to work.

First, collect all background info on the project request

and share it with the team who are gonna

help you to create the estimate.

This could include an intake form, a request

for a proposal, an email or a list of requirements.

Just share it all because context is key

when you're creating estimates.

Be sure to share this info far in advance

of your estimating session so people have

time to think about it and read through documents.

Next, conduct your meeting, sit down

to talk through all the questions your team has.

If there are a lot of open items,

you'll probably want to get back

to your stakeholders and get some answers before proceeding.

If you're ready to go, crack open

your TeamGantt plan or your estimating sheet.

Talk through process at a high level

and make sure you're in agreement

and make adjustments together as needed.

Next, talk through the steps one-by-one,

and make sure the person responsible

for that step is considering the level of effort required.

Make sure you list your assumptions and document

the scope one each task as needed

in case you have to write a scope document

that correlates to your estimate.

Finalize your estimate, and check out

the durations or cost to verify that it

meets the constraints of the project.

Sometimes you'll end up out of range and have

to go back and adjust your scope or estimates.

Other times, you'll be dead-on and feel

really confident, but practice makes perfect,

especially when you're working as a team.

So keep at it, and work out a process that works for you.

When you formalize the process around

how you estimate, you'll actually find

that your estimates will become closer

and closer to your targets over time.

That means you'll be less stressed,

and far more profitable, and that's a good thing.

(intense drumbeats and rhythmic clapping)

Okay, those are the tips I have

around creating project estimates.

I just want to mention that the process I outlined works

really well for Waterfall and hybrid projects.

Estimation in Agile projects is similar,

but also just done in a different way.

It's most important to remember that you have

to set expectations around how you will work

with the Agile environments in order

for your projects to be estimated properly.

There are a couple of rules to consider.

First, if you're truly Agile, your team should

work on one project alone, and nothing else.

If they're not, then you're going to have

a hard time estimating their time.

It's going to become more of a hybrid project.

Next, in Agile all work is done in time-boxed sprints.

That means you're gonna estimate your time

based on the people working on the project

over a specific number of sprints.

It's essentially timeboxing, in other words,

to create an estimate in Agile, you're

basically asking how much does it cost

for our whole dedicated team to work

on only one project for a month,

but it's still really easy to mess up.

You have to consider what roles do you need,

how much time is considered full-time.

Think about company meetings, management tasks

and so on, will your team be truly dedicated,

will there be holidays or time off.

There are a lot of questions to answer,

and expectations to set, but once you've

sorted it all out and set the expectation

of the dedicated team and sprints needed,

you can do some really simple math.

So let's look at this example.

I never talk about rates because they vary

from location to location, company to company

and even person to person, and some companies

don't even charge back rates internally,

so chances are this part doesn't matter to you.

Anyway, we're using a simple round

number to create this estimate.

So, let's say it costs your company $10,000

to dedicate one person to a project

for four weeks and your team does two week sprints.

That would mean that for one person

to complete a sprint, it will cost $5,000.

So, what if your project is six months

long, then you'll need 12 sprints.

And let's say your project will require

four team members over those 12 sprints.

The simple math here would be four resources

times $5,000 per sprint.

That comes to $20,000, but then we multiply

that by 12 sprints and get a total project cost of $240,000.

It seems too easy, right?

Just remember, it will never be perfect.

People will call out, stakeholders will delay.

You'll encounter issues.

There's no doubt this is how all projects work,

but the ease of this process allows you

to truly control scope and process at the same time.

Any time a new change comes in, you can talk

about adding sprints to complete work

rather than incremental fees you have to estimate.

And your flat cost is easy to calculate.

In fact, we did it in the example and the cost

of a sprint was $20,000, simple and pretty pricey.

Okay, so that's estimating at the project level,

and again, even that's problematic because Agile projects

aren't supposed to have a specific ending.

Of course, they end, but until you get

into the process, you don't know

how many sprints you'll actually need.

So again, it will always be just an estimate.

Check out the estimating Agile project homework

download and try this out for yourself

using your own project variables.

(loud drumbeats)

I also want to talk about estimating

at the task level with Agile.

The idea with Agile is that you take

an iterative approach to how the work is done,

but you break the project into smaller pieces

or stories and work on them to shift

functionality independently and the way

you determine what can be done

in a sprint is done through estimation.

It all starts with user stories.

A user story is a tool used in the Agile methodology

to capture a description of a project feature

from an end user's perspective.

The user story describes the type

of user, what they want and why.

A user story helps to create a simplified description

of a requirement and can help to lead you

to a very distinct estimate for the design

and build of that requirement.

Most teams elect to write all stories using this structure.

It helps to cover all of the bases and stay consistent.

The most basic way to estimate a task

is in what we know as humans.

Hours, days, weeks and months.

The Agile methodology erases your memory

of any estimates created with increments of time.

It requires of thinking about estimates,

and that's story points.

This is a number that tells the team

how difficult the user story is

due to complexity, unknowns and effort.

Teams use different scales to determine story points.

Because story points represent the effort

to develop a story, a team's estimate must include

everything that can effect the effort.

That could include the amount of work to do,

the complexity of the work, and any risk

or uncertainty in doing the work.

When estimating with story points,

be sure to consider each of these factors.

What we're looking at here is the Fibonacci sequence

to estimate effort.

Many teams use the sequence as the basis

for producing story points, so, as a story's

being estimated, team members select a number

in the sequence that they believe

represents the level of effort.

The most confusing part of using story

points is determining what the numbers

actually mean in relation to effort.

For instance, how do you know that a three

means the same thing to the whole team.

Well, the best way to determine this with a first time team

is to sit down and define them.

Some teams use planning poker to score stories.

It's a fun, collaborative way to share

ideas on estimates and come up with a final

determination of a story estimate.

T-shirt sizing is another way to sort tasks.

It's high-level but also relatable

and a simple way to convey the size

of something without relying on more detail.

As you can tell, there are several ways to do this.

You can order a planning deck, make your own,

or select values that are more relatable to your team.

For instance, I saw a cool example

that showed London's buildings from size small

to large that a team uses to help estimate tasks.

So you can get creative with your scoring,

just keep in mind that story points pull emotion

out of the estimates by not talking about time.

They focus on task and the size of the task,

not the time you take to get it done.

The minute you start talking about time,

people tend to bring in outlying factors

like time off, working time and other personal things.

Story points allow us to focus back

on the task and only the task.

(drumbeats)

At the end of the day, whether you're Agile

or Waterfall or a little bit of both,

like many of us, you have to come up with a way

of estimating that will work for you.

Follow the rules or break them, that sure

doesn't matter because what really matters

is that you learn about how you do your best work

and get better at estimating over time.

Just so you know, it's never easy.

On that note, we asked some project management experts

what's the most difficult thing about estimating projects.

Let's hear what they have to say.

- I think the trickiest thing about estimating

is not so much the math, but I think

we kind of have a pretty good idea of how

to break things down and come up

with some numbers that make some sense.

I think the trickiest thing is communicating

to people, whether it's your project sponsor

or your boss or the client, communicating

that it's an estimate, it's really a guess,

and not something that they should be writing

in stone somewhere and committing people to.

There's the cone of uncertainty that says,

the further something is out, the less we can

be sure what it is, and we need to communicate

that to people so that we set the right expectations

about what an estimate is and what a quote is

and distinguishing some of those things.

- Well, estimating's one of those things

that quite often it's a finger in the air.

Sometimes you use historical information.

Sometimes we'll gather people together

and ask them what they think, how long

do they think that it will take.

And I often think that the hardest thing

about estimating projects is finding

the right people because people are

so busy these days and they'll go

out of their way to tell you how busy they are.

But once you've gathered the right people,

what you've gotta do is to make sure

you're not trying to be perfect first time.

People spend too long trying to get the absolute

perfect date and it just doesn't work like that.

What you've gotta do is say, at this point

in time, how long do we think that it will take,

who do we think that we will need,

and then you can work out a bit of a cost.

And it's the same whether you're doing Waterfall

or Agile, it's exactly the same.

You only know enough at that point in time.

So, for me, making sure you've got the right

people in the room is key, and then making

sure as you iterate you continue to reevaluate

who are the right people to get in the room,

'cause if you simply use the same people

over and over again, you're closed off to other viewpoints.

Always look for the history.

Always get the right people in the room,

consequently you get a better job at estimating.

- Stop trying to make estimates into exactimates.

They're guesses, they're bad.

They're made with imperfect information

and the problem is that once we make them,

it's sets an expectation and people expect

that we're gonna be good at it,

but if we knew how long it was gonna take,

we wouldn't be estimating, right?

So, it's important to keep for yourself,

for the people on your time, I always encourage

them to track their accuracy with the estimates

so that they can get better, and find ways

to get better at figuring out what things

did I miss last time, how can I not do it next time.

But the biggest challenge I see with estimating

is that people think that that's what's gonna

happen and so, you've got to constantly reset

expectations with the stakeholders and help them

understand that an estimate is just a guess,

and we didn't have the right information to make it.

So, these things are gonna change.

Obviously, you're gonna have to protect yourself

if you're doing budgeting and things like that.

So you might want to leave a little bit

of a buffer there, but giving team members

the freedom to estimate their own work is

really important, and making sure they understand

that we know these estimates are gonna change.

We know they're not gonna be right.

We know there's constantly gonna be flux here.

So, that expectation with the team members

and with the stakeholders is really important.

- What's the hardest thing about estimating projects?

I think it's optimism.

So often our teams and our management want

to think that they can get a task done quicker

than actually ends up being the case.

In order to solve for this, we can break down

all of the parts that might need to be done.

We can remind our team that planning,

conversations, testing, QA, revisions,

all of that needs to be a part

of the task and included in the estimate.

We should also make sure that our team

is talking about their confidence level

in the estimate that they're giving us,

and challenge them when they give us their numbers.

And getting a second opinion is also important

so that we're not just taking the word of one person.

And they're having a conversation

where we're going back and forth

and confirming the estimate that was given.

- Estimating projects is like black magic.

It's inaccurate every time, so I think

the hardest part about estimating is

that people are bad at estimating,

and yet it's a necessity of our industry,

and so we're constantly in this cycle

of trying to get better at a thing that is,

we're just naturally not very good at.

So, what's hard about estimating projects is that it's hard.

- The hardest thing about estimating projects

is that it's just an estimate.

A lot of times when you're working with clients,

they expect you to be perfect in the way

that you are identifying how long or how much

money it's going to take to do something.

When you take a look at putting together

exactly what the requirements are going to be,

and if you have a lot of those details,

it can help make estimating a little bit easier.

One of the things that we do is we stop

looking at it from a number of hours

that it takes to do something, but really start

looking at it from a complexity perspective.

We try to break out tasks so that you

don't find yourself hopping between 15

different things in one given day.

Instead focus on do I think it's gonna take

me the entire day to complete this one item

because it's super hard or do I think I can

probably complete it in half a day.

From that way, you're looking at it

both from a complexity perspective,

but also giving your client the reassurance

of how long will it actually take to do this.

- Alright, that brings us to the end of the class.

I know that estimation is not easy,

but hopefully these tactics will help you

to tackle larger tasks and break them down.

If you do get stuck, ask questions of your team

or colleagues or even prospective clients

because they can usually offer more information.

Don't be nervous about being transparent

about what you don't know because that's gonna

help you when you actually work on the project.

You'll gain trust, you'll learn more,

and you'll deliver what the client needs within budget.

Also, dig deep, nothing is high-level

when you create estimates like this.

Get into the detail so you can understand

what factors are driving your estimates.

Look back on similar projects and see

what they were like and if they were on budget.

If you aren't tracking project histories

in the form of high level retrospective notes

or logged hours in a time tracking tool,

you should start now, and finally, remember

that no estimates are set in stone.

List your assumptions, discuss risks,

and work out an estimation process

that works for you and your team.

Don't forget to grab the class downloads.

Have some fun with the homework assignments.

Test out TeamGantt and get better at estimating.

Come back for class four which will be all about gathering

and documenting project requirements.

(upbeat music)