Latest / DevQuestions with Tim Corey / 320. How To Survive as a Solo Developer

Transcript

320. How To Survive as a Solo Developer · DevQuestions with Tim Corey

• 0:00
  SPEAKER_01: What do you do when you're the only developer at a company?
• 0:03
  SPEAKER_01: What are the tips and tricks for getting the most done while not making an absolute mess out of things?
• 0:09
  SPEAKER_01: Solo development is almost entirely a different field than development on a team.
• 0:15
  SPEAKER_01: So let's talk about the things you can do to survive and thrive in this type of environment in today's episode of DevQuestions.
• 0:31
  SPEAKER_00: Welcome to the Dev Questions Podcast with Tim Corey.
• 0:35
  SPEAKER_01: Software development is more than just writing code.
• 0:38
  SPEAKER_01: So let's talk about the rest of it.
• 0:39
  SPEAKER_01: Specifically, let's talk about being a solo developer.
• 0:43
  SPEAKER_01: Now, before we get into how to survive and thrive in this type of environment, I do want to acknowledge that being a solo developer can look different from situation to situation.
• 0:52
  SPEAKER_01: It could be that you're building a product on your own or a business on your own, or it could be that you're a solo consultant working for a customer that doesn't have a development department.
• 1:04
  SPEAKER_01: Or it could be that you've been hired to build custom software full-time for a company where you're the only developer.
• 1:12
  SPEAKER_01: Whatever the case may be, and I've done all of these myself, there are some constants that can help you out.
• 1:18
  SPEAKER_01: And just to be clear, this advice can actually help teams of any size, but it's gonna be especially helpful for a solo developer.
• 1:25
  SPEAKER_01: All right, number one, this is probably the biggest one and the one that's gonna take the most work to work through.
• 1:31
  SPEAKER_01: And that is you can only support a limited amount of code.
• 1:36
  SPEAKER_01: That's it's a hard thing to acknowledge.
• 1:39
  SPEAKER_01: And often people don't agree.
• 1:43
  SPEAKER_01: And that may be the developer themselves or maybe their management.
• 1:47
  SPEAKER_01: But either way, this gets a lot of pushback.
• 1:50
  SPEAKER_01: But here's the reality: at some point, you run out of ability to keep building.
• 1:58
  SPEAKER_01: And honestly, this happens for a team of one or a team of 200.
• 2:03
  SPEAKER_01: There's only so much code that you can support.
• 2:06
  SPEAKER_01: Because when you write code, you don't just write code, complete it, and never touch it again.
• 2:13
  SPEAKER_01: That almost never happens, and it really only happens for very, very specific situations.
• 2:20
  SPEAKER_01: For the most part, you are fixing bugs, you are making changes to how the code works, you're adding new features, you are updating it to work with newer operating systems or newer network environments or changes in the way you're doing storage or something else.
• 2:38
  SPEAKER_01: These things happen a lot.
• 2:40
  SPEAKER_01: And so when you write code, you're by design adding in some support time to your day for the rest of the time until that code goes away.
• 2:53
  SPEAKER_01: So it's kind of like building a building.
• 2:56
  SPEAKER_01: I worked for a college once and they built this brand new, very large building.
• 3:02
  SPEAKER_01: And during the discovery process of how much is going to cost and how much money do we need to raise and all that thing, that work, one of the things they found that was consistent across a number of different organizations that had built large buildings like this was that you need to set aside a significant amount of money for every year for maintenance.
• 3:24
  SPEAKER_01: And so their suggestion was at least put 10% of the cost of the building aside and make sure that's for maintenance.
• 3:32
  SPEAKER_01: And that should be building interest or some other way to put money in and continue that fund because maintenance, the business, the building isn't free, right?
• 3:42
  SPEAKER_01: You build this brand new building.
• 3:43
  SPEAKER_01: Think of your house.
• 3:44
  SPEAKER_01: You build a brand new house.
• 3:46
  SPEAKER_01: It doesn't matter if it's brand new.
• 3:48
  SPEAKER_01: Something's gonna break.
• 3:50
  SPEAKER_01: Something's gonna go wrong.
• 3:51
  SPEAKER_01: You're gonna need to do some type of work.
• 3:53
  SPEAKER_01: I just put a whole bunch of money into my house because I had a septic pipe break.
• 3:59
  SPEAKER_01: So I had to pay for a septic pipe to replace and the digging and the all this stuff.
• 4:04
  SPEAKER_01: This is normal home ownership stuff.
• 4:06
  SPEAKER_01: Well, the same is true for code.
• 4:09
  SPEAKER_01: Things are gonna break.
• 4:11
  SPEAKER_01: Things are gonna need to be maintained.
• 4:13
  SPEAKER_01: And so you need to put aside a budget of time to maintain that thing, which means at some point, the entirety of your time, because it is finite, the entirety of your time will be dedicated to maintenance, which means nothing new in theory can be built.
• 4:36
  SPEAKER_01: Now, companies don't like to admit this, whether it's a building or a piece of software.
• 4:41
  SPEAKER_01: They don't like to admit that there is any cost beyond the upfront cost.
• 4:46
  SPEAKER_01: They think that when they when they buy the initial thing, that should be it.
• 4:51
  SPEAKER_01: But that's not how life works.
• 4:54
  SPEAKER_01: So when you start building code and you write this really cool application that supports this department, great, that's awesome.
• 5:03
  SPEAKER_01: But what you're doing then is you are saying, I now have 5% less time in my week because of maintaining that one thing.
• 5:14
  SPEAKER_01: Which means if I do that 20 times, I'm uh I'm out of work.
• 5:19
  SPEAKER_01: Like I have no more ability to create new things.
• 5:23
  SPEAKER_01: This is, and we'll probably talk about it in a separate week, but this is opportunity cost.
• 5:28
  SPEAKER_01: You've said yes to one thing, which means you're actually saying no to something else.
• 5:35
  SPEAKER_01: And I know we've all been there where our bosses just don't understand that.
• 5:40
  SPEAKER_01: And they say, well, I want you to say yes to this, but also that.
• 5:45
  SPEAKER_01: And we'll talk more about how to maintain that and manage that, you know, in other points.
• 5:50
  SPEAKER_01: But it's really important that you understand that there's only so much code that you can support.
• 5:56
  SPEAKER_01: And yes, I know there's AI now, and it can do wonderful things.
• 6:01
  SPEAKER_01: That doesn't change the fact.
• 6:04
  SPEAKER_01: Now, yes, AI might be able to make you faster as a developer if you use it correctly, but that doesn't mean that you just have unlimited maintenance now.
• 6:14
  SPEAKER_01: It just means that you might have a slightly bigger pool to work with for maintaining.
• 6:20
  SPEAKER_01: So you might be able to do a few more projects before you're out of time again.
• 6:25
  SPEAKER_01: So, what's the conclusion here?
• 6:28
  SPEAKER_01: Well, don't just build everything you can build.
• 6:31
  SPEAKER_01: Build things that are the most important.
• 6:34
  SPEAKER_01: And you know what?
• 6:35
  SPEAKER_01: Sometimes the best solution is to say, let's not build something, let's buy something.
• 6:41
  SPEAKER_01: I run my own company.
• 6:43
  SPEAKER_01: I write a lot of the software that we run, we use.
• 6:47
  SPEAKER_01: And that's something that's important to me as well, because I know that the more code that I have written, the more time I spend maintaining that code, the less time I spend teaching.
• 6:59
  SPEAKER_01: And my primary goal is to be teaching, which means I am very limited in how much code I can write.
• 7:06
  SPEAKER_01: In fact, I've had my team tell me for years now, we want this, we want that.
• 7:11
  SPEAKER_01: I would love to build these things.
• 7:13
  SPEAKER_01: I don't have the time.
• 7:14
  SPEAKER_01: I don't have the time to build it initially, but more than that, I don't have the time to maintain it.
• 7:21
  SPEAKER_01: And that's why we have a mobile app for finely, for our um our students who purchase courses.
• 7:28
  SPEAKER_01: So if you purchase a course, you can get a mobile app in an iOS or Android.
• 7:32
  SPEAKER_01: But I didn't write that.
• 7:33
  SPEAKER_01: I had somebody else that wrote that, and then I just pay for it.
• 7:37
  SPEAKER_01: I pay annually for it because it's easier for me to pay for that and say, you know what, this is cheaper than me spending time maintaining it.
• 7:50
  SPEAKER_01: So you need to think about buy versus build.
• 7:53
  SPEAKER_01: Okay.
• 7:54
  SPEAKER_01: So number one, it's really important to understand this.
• 7:57
  SPEAKER_01: You only can support a limited amount of code.
• 8:01
  SPEAKER_01: Number two, automate everything, which kind of feels like it goes against number one, but it doesn't.
• 8:08
  SPEAKER_01: So you need to look at your entire job and say, what can I automate?
• 8:14
  SPEAKER_01: And try to automate everything you can.
• 8:18
  SPEAKER_01: So let's look at this from a purely software standpoint.
• 8:23
  SPEAKER_01: When you write software, let's say you write, maybe you're writing a desktop app for a company.
• 8:29
  SPEAKER_01: When you write that code, maybe you make a change to it, what happens then?
• 8:34
  SPEAKER_01: In a lot of companies, what happens is you go to Visual Studio, you say publish, and then you publish to an executable, and then you put that executable in a place in the drive, or maybe you use a MSI and then you push that out the network.
• 8:47
  SPEAKER_01: It's a lot of manual steps.
• 8:49
  SPEAKER_01: Automate that.
• 8:50
  SPEAKER_01: Continuous integration, continuous deployment.
• 8:54
  SPEAKER_01: It should be that when you write that code and say, yes, let's commit that to our repository into the production branch or into the production, you know, we mark it as production, whatever you want to do as far as how you designate it.
• 9:07
  SPEAKER_01: But when you say this goes to production, automation should take it from there until it gets all the way into production as much as possible.
• 9:16
  SPEAKER_01: Automate as much of your job as possible.
• 9:19
  SPEAKER_01: That way it's always consistent.
• 9:22
  SPEAKER_01: That way you're not trying to remember and missing steps every once in a while, which causes more support issues.
• 9:28
  SPEAKER_01: That way you make sure that you are not doing any more grunt work, any more repetitive work than humanly possible, so that you have more time to support code.
• 9:42
  SPEAKER_01: Because the more time you have, the more code you can support.
• 9:47
  SPEAKER_01: Number three, write simpler code.
• 9:51
  SPEAKER_01: Now, as a senior developer, this is something that you should be doing anyway.
• 9:55
  SPEAKER_01: But this also means writing simpler code sometimes means not doing all the cool stuff.
• 10:02
  SPEAKER_01: Uh for a while I worked for a company where we were um rewriting our UI, which was an ASP net um uh just ASP pages.
• 10:12
  SPEAKER_01: Um ASP or ASP net, web forms.
• 10:14
  SPEAKER_01: It was web forms.
• 10:16
  SPEAKER_01: Um I didn't spend a lot of time in them.
• 10:18
  SPEAKER_01: Um but we were rewriting those into Angular.
• 10:22
  SPEAKER_01: And Angular can do a lot of cool things.
• 10:25
  SPEAKER_01: But instead of doing all the cool things it could do, I really trim it down to just a few things because it was easier to maintain.
• 10:34
  SPEAKER_01: Instead of having things all over the place, or instead of you know having this complex setup that's you know, quote unquote, right, I made a simpler setup because it was faster to maintain.
• 10:46
  SPEAKER_01: And because it was faster to maintain, it was easier to maintain.
• 10:50
  SPEAKER_01: We could maintain more code.
• 10:52
  SPEAKER_01: So write simpler code.
• 10:55
  SPEAKER_01: Just because you can doesn't mean you should.
• 10:58
  SPEAKER_01: Okay, just because you can write something complicated, or just you can have all these different layers to make sure that everything has its own specific uh delineation, there's separation concerns everywhere, doesn't mean you always should.
• 11:14
  SPEAKER_01: Number four, set clear expectations.
• 11:18
  SPEAKER_01: When you're talking to your boss, when you're talking to the people you're building applications for, you need to set clear expectations.
• 11:25
  SPEAKER_01: You need to be clear about what you can do, what you can't do, and what the costs associated are.
• 11:32
  SPEAKER_01: When you're working as a solo developer at a company where you're a full-time salary employee, often people think that your time is free.
• 11:40
  SPEAKER_01: And it's not.
• 11:42
  SPEAKER_01: Refer back to point one.
• 11:44
  SPEAKER_01: You can only support a limited amount of code.
• 11:46
  SPEAKER_01: So when you are talking about the costs of something, you should be talking, including the opportunity costs.
• 11:53
  SPEAKER_01: Hey, if I build this marketing app, then I won't have time to build this sales app.
• 12:01
  SPEAKER_01: Hey, if I if I build this marketing app, I'm not gonna have time to maintain or fix the bugs in this other app.
• 12:10
  SPEAKER_01: Okay, so you're setting up clear expectations about what's the priority here?
• 12:15
  SPEAKER_01: Because if that's the priority, that's what I'll do.
• 12:17
  SPEAKER_01: But here's what you're going to lose.
• 12:20
  SPEAKER_01: Here's the costs associated.
• 12:22
  SPEAKER_01: So set clear expectations.
• 12:24
  SPEAKER_01: Set clear expectations on your time.
• 12:26
  SPEAKER_01: You know, it if a project is going to take you 100 hours, you should not quote two weeks.
• 12:33
  SPEAKER_01: You might say, well, I can push a little bit extra.
• 12:36
  SPEAKER_01: You know, 10 hours extra a week, 50 hours a week, two weeks.
• 12:40
  SPEAKER_01: No, don't do that.
• 12:41
  SPEAKER_01: Don't do that.
• 12:42
  SPEAKER_01: Set clear expectations and say, this is going to take 100 working hours.
• 12:48
  SPEAKER_01: Every meeting I have takes away from that.
• 12:51
  SPEAKER_01: Every time I get pulled aside to do a bug fix, it takes away from that.
• 12:57
  SPEAKER_01: And I only have at most 40 hours a week to start from.
• 13:02
  SPEAKER_01: So that means two and a half weeks even isn't realistic because I have five meetings a week, you know, an hour each meeting.
• 13:11
  SPEAKER_01: So that's five hours where I'm not doing this.
• 13:14
  SPEAKER_01: And I have to respond to email and talk to coworkers and and all these other things, they're going to take another 10 hours a week.
• 13:21
  SPEAKER_01: So now I'm down to 25 hours a week.
• 13:23
  SPEAKER_01: That means four weeks to do this project.
• 13:26
  SPEAKER_01: And then if you pull me aside to do something else, that takes away.
• 13:29
  SPEAKER_01: And when you're clear about those expectations and clear about what it's going to cost, then it's clear when they pull you aside for a meeting that they're saying yes to the meeting means no to this project.
• 13:43
  SPEAKER_01: Doesn't mean the project goes away, it just means that project gets pushed off because of the meeting.
• 13:49
  SPEAKER_01: So saying clear expectations will really be helpful.
• 13:53
  SPEAKER_01: Number five, be transparent about what you do.
• 13:58
  SPEAKER_01: Too often, people think that software developers are this black box, right?
• 14:04
  SPEAKER_01: Where the requirements go in, an application comes out.
• 14:08
  SPEAKER_01: And maybe don't bug the developer or kind of just poke them a stick and hope that things come out that you want to come out.
• 14:17
  SPEAKER_01: Don't do that.
• 14:18
  SPEAKER_01: Make sure that people understand what you do and how you do it.
• 14:22
  SPEAKER_01: Now, obviously, you're not going to be teaching them, well, maybe not, but you probably won't be teaching them software development.
• 14:28
  SPEAKER_01: You probably won't be teaching them all the parts of the process you go through.
• 14:32
  SPEAKER_01: But you should be making sure they know as much as possible about why you do what you do, about why it takes the time that it takes, about how when you give them a demo UI, that's not just Ray for production.
• 14:48
  SPEAKER_01: Like, and this is also where side note, demo UIs should not look like they're actually usable.
• 14:54
  SPEAKER_01: They should be, if they're not actually drawn out on something, you should get a tool that makes it look like a sketch.
• 15:00
  SPEAKER_01: Don't make it a real application.
• 15:02
  SPEAKER_01: Um, it might be even easier.
• 15:05
  SPEAKER_01: Um, the fact is, people will misunderstand that.
• 15:08
  SPEAKER_01: You want to be transparent about what you do, not be confusing about what you do.
• 15:13
  SPEAKER_01: You need people to understand why it's going to take extra time when they ask for something later.
• 15:20
  SPEAKER_01: You need to be transparent about how a change now near the end of the process really changes the entire application, not just a little tweak.
• 15:31
  SPEAKER_01: Be transparent about what you do because they don't know what you do.
• 15:35
  SPEAKER_01: And so when you come back with something they don't expect, like, hey, it's just a little project, just a little project, and you say, that's three months of work, they don't just feel like you're pushed them off.
• 15:48
  SPEAKER_01: They feel like you're being honest about the fact that it's a lot bigger than I expected.
• 15:53
  SPEAKER_01: And tell them why.
• 15:54
  SPEAKER_01: Tell them why it's not just as simple as a little UI here or there, and all of a sudden the application's done.
• 16:02
  SPEAKER_01: Okay.
• 16:03
  SPEAKER_01: So make help them understand what you do because if you're a solo developer, there's probably no one at the company that knows exactly what you do or how you do it.
• 16:14
  SPEAKER_01: And so if they don't know what you do, then they're not going to have good expectations about what you should be doing or if you're even doing a good job or not.
• 16:24
  SPEAKER_01: So be transparent.
• 16:26
  SPEAKER_01: Number six, and I think this is you know life advice for everybody, but it really applies here as well.
• 16:32
  SPEAKER_01: So let's let's make sure we're clear about it.
• 16:34
  SPEAKER_01: Don't be a jerk.
• 16:36
  SPEAKER_01: There you go.
• 16:37
  SPEAKER_01: That's if you had to have one piece of life advice for everything, just don't be a jerk.
• 16:44
  SPEAKER_01: But in this place specifically, it's really important because you have the opportunity to be a jerk.
• 16:53
  SPEAKER_01: When you're the sole developer in a company, sometimes the company feels like you kind of have a stranglehold on them.
• 17:01
  SPEAKER_01: Because if you left, like what would happen?
• 17:04
  SPEAKER_01: Like things would fall apart.
• 17:05
  SPEAKER_01: Oh my goodness, we wouldn't know what to do if we don't know what you do.
• 17:09
  SPEAKER_01: So you have the opportunity to be that jerk who you know everybody kind of hates, but you have to put up with because you have no other choice.
• 17:18
  SPEAKER_01: Don't be that person because that leads to resentment not to working together as a team member.
• 17:26
  SPEAKER_01: That leads to them trying to figure out how to get rid of you instead of being thrilled that you're there.
• 17:33
  SPEAKER_01: Okay.
• 17:33
  SPEAKER_01: Don't be a jerk.
• 17:35
  SPEAKER_01: It's going to make your life easier.
• 17:37
  SPEAKER_01: If you're a consultant, it means you probably get called back for the next job, right?
• 17:41
  SPEAKER_01: If you are a full-time employee, maybe you you miss out on the layoffs, right?
• 17:47
  SPEAKER_01: Like there's a really it's important to understand that just because you're a software developer doesn't give you a license to be a bad person.
• 17:57
  SPEAKER_01: Okay.
• 17:58
  SPEAKER_01: Don't be a jerk.
• 17:59
  SPEAKER_01: Being a solo developer can be a great job.
• 18:03
  SPEAKER_01: I I have loved it through my career.
• 18:05
  SPEAKER_01: Like I said, I've done it a number of different ways, and it's a lot of fun.
• 18:10
  SPEAKER_01: But it's you can also make a mess out of it.
• 18:13
  SPEAKER_01: Okay.
• 18:13
  SPEAKER_01: Use these tips to survive and thrive in the role of software developer.
• 18:19
  SPEAKER_01: Thanks for listening.
• 18:20
  SPEAKER_01: As always, I am Tim Corey.
• 18:22
  SPEAKER_00: Thank you for joining us for this episode of Dev Questions.
• 18:25
  SPEAKER_00: When you're ready to learn to think and code like a professional developer, head over to IamtimCorey.com and enroll in a course.