Latest / DevQuestions with Tim Corey / 017 What is Scope Creep? How Do You Prevent Scope Creep?

Transcript

017 What is Scope Creep? How Do You Prevent Scope Creep? · DevQuestions with Tim Corey

• 0:00
  SPEAKER_00: Welcome to the Dev Questions Podcast with Tim Corey.
• 0:03
  SPEAKER_00: Join us each episode as we tackle the questions you are asking about a career in software development, understanding the industry, and new technology.
• 0:12
  SPEAKER_00: If you're just starting out or you want to grow stronger as a developer, this is the place to get your questions answered.
• 0:19
  SPEAKER_00: Now, here's your host, expert developer and online educator, Tim Corey.
• 0:25
  SPEAKER_01: What is scope creep?
• 0:27
  SPEAKER_01: And how do we prevent scope creep?
• 0:30
  SPEAKER_01: These are the questions that I was asked recently that we're going to cover in today's DevQutions topic.
• 0:36
  SPEAKER_01: Now, if you're not familiar with DevQuestions, each week I cover a question that you have about being a developer.
• 0:44
  SPEAKER_01: Whether you are a developer or are trying to break into the development sphere, these are questions that come up often that I'm going to cover for you.
• 0:53
  SPEAKER_01: Now, today's topic is about scope creep.
• 0:56
  SPEAKER_01: And the let's start with defining what is scope creep.
• 1:00
  SPEAKER_01: So when we're building applications, there is an initial enthusiasm that comes from building our application, seeing our vision come to life in application.
• 1:13
  SPEAKER_01: I understand that.
• 1:21
  SPEAKER_01: The conceptual view of man, we could do this, we could do that.
• 1:26
  SPEAKER_01: And that's where scope creep starts.
• 1:29
  SPEAKER_01: When we're building an application, we look at this and we say, okay, here's what we're gonna build.
• 1:34
  SPEAKER_01: We're gonna build an application that does X.
• 1:37
  SPEAKER_01: Then we say, you know what would be really cool if we add this piece to it, because it'd make it even better of an application.
• 1:44
  SPEAKER_01: And it should probably do this as well.
• 1:46
  SPEAKER_01: And that's where that's scope creep.
• 1:49
  SPEAKER_01: The idea that we had an initial vision for our application.
• 1:52
  SPEAKER_01: We said, we want to accomplish this goal.
• 1:56
  SPEAKER_01: And then we start adding to it good things.
• 2:00
  SPEAKER_01: And that's that's a key point here.
• 2:02
  SPEAKER_01: Scope creep is not about bad things, it's not about allowing bad pieces of logic or bad or bad ideas into your application, it's about allowing good things into your application too early.
• 2:18
  SPEAKER_01: So scope creep is the idea that your application grows before it's done.
• 2:26
  SPEAKER_01: And so it's a continual moving finish line.
• 2:30
  SPEAKER_01: So you've set an initial goal and you said this is the finish line, this is point B.
• 2:34
  SPEAKER_01: And then Scope Creep comes and says, Well, actually, let's make the finish line point C.
• 2:40
  SPEAKER_01: And so now you have to go to point B, but you're not done.
• 2:42
  SPEAKER_01: You have to go to point C.
• 2:44
  SPEAKER_01: And then before you're done to point C, you say, Hey, you know what?
• 2:49
  SPEAKER_01: There's point D and E.
• 2:51
  SPEAKER_01: We should probably hit those two.
• 2:53
  SPEAKER_01: And now your finish line is point E.
• 2:56
  SPEAKER_01: And you have to, you've gone through point B, you've gone through point C, and you still haven't finished your application.
• 3:02
  SPEAKER_01: You have to keep adding to it.
• 3:05
  SPEAKER_01: That's scope creep.
• 3:06
  SPEAKER_01: The idea that the finish line continues to move.
• 3:10
  SPEAKER_01: We add more things between the start of our project and the end of our project, which makes the overall project length longer or larger.
• 3:21
  SPEAKER_01: Now, the first question you have to ask is is that a bad thing?
• 3:26
  SPEAKER_01: Is it bad that we are evaluating what this could be and making sure we add the best stuff into our application?
• 3:35
  SPEAKER_01: And the answer is maybe.
• 3:37
  SPEAKER_01: And that sounds harsh because these are good things.
• 3:40
  SPEAKER_01: We're not talking about bad things.
• 3:42
  SPEAKER_01: These are good improvements, right?
• 3:45
  SPEAKER_01: Yes and no.
• 3:47
  SPEAKER_01: The problem is that it doesn't matter how awesome your application is if it never reaches production.
• 3:57
  SPEAKER_01: If you have an amazing application that does tons of stuff, but no one can ever use it because it's not done yet, is it really that amazing?
• 4:08
  SPEAKER_01: Or is it just fun code?
• 4:12
  SPEAKER_01: And that's the problem with scope creep.
• 4:15
  SPEAKER_01: It hinders your overall goal for the sake of a better overall goal.
• 4:22
  SPEAKER_01: And that's the lie that it tells you is it's a better goal.
• 4:26
  SPEAKER_01: So, how do we prevent against scope creep?
• 4:29
  SPEAKER_01: How do we keep this good stuff and yet at the same time get our application launched and not move our end goal, not move from point B to point C before we've launched.
• 4:42
  SPEAKER_01: And the way I do that is by having a list.
• 4:47
  SPEAKER_01: I love lists.
• 4:49
  SPEAKER_01: I have lists all over.
• 4:51
  SPEAKER_01: I use OneNote for lists like crazy.
• 4:54
  SPEAKER_01: I've got tons and tons of tabs with lists.
• 4:58
  SPEAKER_01: When you're building an application, you want a easy-to-use, quick to access list that you call version next.
• 5:07
  SPEAKER_01: Whether it's version 1.1 or version 2, doesn't matter what you call it, it should be these are really cool things that we're not going to do yet.
• 5:18
  SPEAKER_01: These are things that come in the future.
• 5:21
  SPEAKER_01: We're going to keep our eye on those because maybe we architect our application a little differently with that in mind.
• 5:28
  SPEAKER_01: So maybe we say, you know what, it'd be really cool to have plugins for our application.
• 5:36
  SPEAKER_01: But that's not version one.
• 5:38
  SPEAKER_01: So instead, we'll just keep that in mind that it might have plugins, so we don't architect it in a way that would prevent plugins.
• 5:46
  SPEAKER_01: But we don't spend a whole lot of time getting plugins to work now.
• 5:51
  SPEAKER_01: We wait until later, until version 1.1 or version 2.0.
• 5:56
  SPEAKER_01: This comes down to the idea that we're building a minimum viable product.
• 6:02
  SPEAKER_01: That's called an MVP.
• 6:03
  SPEAKER_01: And people often get confused as to what an MVP is.
• 6:08
  SPEAKER_01: An MVP is version one.
• 6:12
  SPEAKER_01: That's the version where the application just does the thing, the most important thing, the thing that you designed everything to focus around.
• 6:24
  SPEAKER_01: So let's say a simple example: a to-do list.
• 6:27
  SPEAKER_01: You're gonna build a to-do list where you put to-dos on it and you take them off.
• 6:33
  SPEAKER_01: That's really what that is.
• 6:35
  SPEAKER_01: But if you're not careful, a to-do list becomes a well, what if we synchronize that with a cloud?
• 6:40
  SPEAKER_01: What if we had multiple users?
• 6:42
  SPEAKER_01: What if we had different categories?
• 6:45
  SPEAKER_01: What if we, and these are all great ideas.
• 6:48
  SPEAKER_01: They're all ideas that probably should be pursued, but not yet.
• 6:54
  SPEAKER_01: Your minimum viable product is a list that you can put things on and take things off.
• 7:00
  SPEAKER_01: That's a to-do list.
• 7:02
  SPEAKER_01: Now, you may want to go well beyond that.
• 7:05
  SPEAKER_01: You may not be satisfied with that as your end product, but that is the core of your application.
• 7:13
  SPEAKER_01: So whenever you're building an application, keep the core in mind.
• 7:18
  SPEAKER_01: What is the one thing our application should do?
• 7:22
  SPEAKER_01: Not the 10 things, not the 100 things.
• 7:24
  SPEAKER_01: What's the most important thing our application should do?
• 7:29
  SPEAKER_01: That is your minimum viable product.
• 7:32
  SPEAKER_01: Now, there may be more things that you need to add to that eventually.
• 7:37
  SPEAKER_01: It may be that your minimum viable product is just barely adequate to do anything, and that's why it's called minimum viable product.
• 7:48
  SPEAKER_01: It's barely viable, it's just barely considered an application.
• 7:54
  SPEAKER_01: But guess what?
• 7:56
  SPEAKER_01: Once you have a working application, you can add to it.
• 8:00
  SPEAKER_01: You can add those features.
• 8:02
  SPEAKER_01: And that's where the fun comes in.
• 8:04
  SPEAKER_01: Because if you continue to move the end goal, so if you start saying, I'm gonna go from point A to point B, and now it's point C and now it's point D, and now it's point E, and you never get there, that's discouraging.
• 8:18
  SPEAKER_01: But if you get to point B and you launch, and then you move to point C and you launch again, and then you move to point D and you launch again.
• 8:29
  SPEAKER_01: So version 1.0, 1.1, 1.2, 2.0, you've now had three, four, five, six launches where you saw your product improve, where you saw your product being used.
• 8:44
  SPEAKER_01: That's encouraging.
• 8:46
  SPEAKER_01: So a lot of little launches is gonna be a whole lot more encouraging to you than waiting and waiting and waiting.
• 8:55
  SPEAKER_01: The other part of this is that the sooner you get your product in the hand of users, the sooner you hear feedback.
• 9:04
  SPEAKER_01: And that feedback is very important because often we have this idea in our minds of what the application should be, what it should look like, how it should work.
• 9:14
  SPEAKER_01: But then when the user gets it, they don't get it.
• 9:17
  SPEAKER_01: They don't understand, they don't figure out how it works, or or they don't like something, or they bypass something and say, you know what, I don't like this feature.
• 9:24
  SPEAKER_01: I wouldn't use this feature, but I wish it had that.
• 9:28
  SPEAKER_01: The sooner you put something in the user's hands, the sooner you get that feedback.
• 9:32
  SPEAKER_01: The sooner you get that feedback, the sooner you can change to accommodate what the user actually needs and wants.
• 9:40
  SPEAKER_01: So scope creep is dangerous to your application to the point of deadly.
• 9:47
  SPEAKER_01: Your the number of applications that have died before launch is staggering.
• 9:53
  SPEAKER_01: I know I have a lot.
• 9:55
  SPEAKER_01: I have a backlog of applications where I never launched them because I kept adding features to it and it never got to the point of launch, and I got discouraged, and I just moved on, or it's no longer relevant.
• 10:08
  SPEAKER_01: I would encourage you to launch early.
• 10:12
  SPEAKER_01: Have in your head the minimum viable product.
• 10:17
  SPEAKER_01: Understand what the very core of your application is, understand what that seed is, and just focus on that.
• 10:27
  SPEAKER_01: But don't give up on those good ideas.
• 10:30
  SPEAKER_01: They're gonna come throughout the process.
• 10:33
  SPEAKER_01: Just don't let them distract you.
• 10:35
  SPEAKER_01: So when you have a great idea, write it down.
• 10:39
  SPEAKER_01: And then keep going on your core idea.
• 10:41
  SPEAKER_01: Write it down, keep going.
• 10:44
  SPEAKER_01: And then when you launch your minimum vital product, you will not only have a working application, you will have a list of things on your roadmap to move on to.
• 10:56
  SPEAKER_01: And then you can pick the most important one and make that your next goal, and make that the next minimum vital product for that improvement.
• 11:06
  SPEAKER_01: And now you can keep going from there and iterate.
• 11:09
  SPEAKER_01: So that's why I encourage you as scope creep, be very, very careful of it.
• 11:13
  SPEAKER_01: Scope creep is good things that distract you from the best things.
• 11:20
  SPEAKER_01: So make sure that you don't just give in and say, that's a good thing, I should do it.
• 11:26
  SPEAKER_01: Make sure that you focus on your minimum viable product, focus on getting this particular version, this particular feature, or this particular application that does just this out the door and move those other things, those good things, to the waiting list.
• 11:45
  SPEAKER_01: If you do that, you will reduce the amount of scope creep you have.
• 11:50
  SPEAKER_01: If you do that, you will see more success, you'll see more launches, you'll see more people use your application than if you give in to the list of good things that adds up to a bad thing.
• 12:05
  SPEAKER_01: Okay, so that's scope creep.
• 12:07
  SPEAKER_01: That's my thoughts on it.
• 12:08
  SPEAKER_01: That's how you can avoid it.
• 12:09
  SPEAKER_01: I hope that you found this episode enjoyable and enlightening.
• 12:13
  SPEAKER_01: And I hope that if you have a question about being a developer, that you will let me know.
• 12:19
  SPEAKER_01: There is on the podcast page a link to say, hey, I've got a question and fill that out.
• 12:25
  SPEAKER_01: Or you can email me, or you can post a comment down below the YouTube video and say, hey, here's a question I have about being a developer.
• 12:33
  SPEAKER_01: And I'll add to the list and I'll try and get to it as soon as possible.
• 12:37
  SPEAKER_01: Thanks for listening.
• 12:38
  SPEAKER_01: As always, I am Tim Corey.
• 12:40
  SPEAKER_00: Thank you for joining us for this episode of Dev Questions.
• 12:43
  SPEAKER_00: Tim is committed to making it easier for you to become a developer.
• 12:47
  SPEAKER_00: If you would like to help make more content like this possible, please like, subscribe, rate, and share Dev Questions.
• 12:54
  SPEAKER_00: You can also send your questions to questions at IamtimCore.com.
• 12:59
  SPEAKER_00: Until next time, remember, you are too smart and your time too valuable to waste it making all the mistakes Tim did.
• 13:06
  SPEAKER_00: When you're ready to learn to think and code like a professional developer, head over to imtimcore.com and enroll in a course.