3 ms·
I like to try to build tiny MVPs (or micro prototypes) during the planning process itself. If someone hands me a big project, I'll take a few days to break it d
by solardev 2y ago
I like to try to build tiny MVPs (or micro prototypes) during the planning process itself. If someone hands me a big project, I'll take a few days to break it down into bite size pieces and try to make a super simple prototype for each piece.
For example, what are the user flows required (login, checkout, change settings, blah blah). How many screens does each one take? How long does it take me to build 2 screens and the connection between them? I'll try it, time myself, and then multiply that out.
For the API, what endpoints are required? What's the most difficult one, like auth? Try to implement a simple version of that. Do the same for another easier endpoint. Average them out. Buffer for shared infrastructure config time (all the CI/CD stuff, IAM, dozen Docker and yaml files...). But still try to build a couple small ones and then extrapolate from that.
Add in multipliers for adding tests, project management (especially if there's Agile bullshit and lots of Jira), QA, UI polish, accessibility, security testing, etc.
Whatever you end up with, add 20% on top it at least.
It's always a negotiation. If you come in with a too high number, it sets more realistic expectations and might get you additional resources. If you come in low, you'll just end up cutting corners and disappointing everyone in the end.
Document the hell out of everything and present it as a retrospective of the process itself, and use it to better improve the estimation and development process going forward (this IMHO is the real value, more than any one single estimation in and of itself). It lets you identify bottlenecks and "what I didn't know I didn't know" pain points that are different for every dev, ie what they ended up missing the estimates on by a lot.
Mostly the thing to keep in mind that the software estimation process is itself an algorithm that can be debugged, refactored, and improved over time.