Let’s use this issue to reiterate over one of my more important tweets from last week. In this case, it’s all about projects, especially on GitHub (or Gitlab or wherever else you can host source code in the open).
Especially if you have zero to no experience or want to enter a new field, it’s super tricky for hiring managers and other technical staff to evaluate what you are capable of. In the end, a company wants to pay money for someone they know can hold their ground up to a certain extent. And it’s their good right to do so.
But even if you have no professional experience in a specific field to show, you can still build a showcase of your abilities by building a portfolio of projects. Those projects don’t even need to be very special or unique. All you should focus on is diving deeper into a field and work on showcasing that you understood how to implement specific things in a way that makes some kind of software actually run.
What you should do
Let’s take a look at what you should do to get the maximum out of your GitHub portfolio:
- Focus on finishing your projects
- Build something that actually makes sense
- Take care of everything from start to finish
Those are the three main points I would keep my focus on. But let’s go over them a little more in-depth so you understand the what and why.
Focus on finishing your projects
It might not seem like much, but this point is actually one of the most important ones.
When working a 9-to-5, you get paid to get things done. It’s not about starting a dozen different projects and only finishing a few of them.
You usually work on finishing, extending, or maintaining a relatively large project that hopefully brings someone more money than they previously had. Chances are also high that you work on something that saves someone else a lot of money in the long run (by making things more effective or faster).
This is where your ability to finish things comes into play. It’s your job to push this project further. Every feature you implement or bug you fix helps with this process.
Showcasing that you are capable of actually finishing things helps others a lot to evaluate your overall mentality. Additionally, finished projects are usually a way better showcase of your ability than unfinished ones that you can’t even see running at all.
Build something that actually makes sense
This one is probably a little controversial, but let’s take a deeper look at what I mean by this.
Even a Todo app makes sense because it solves a particular problem. It doesn’t matter that there are already a gazillion todo apps out there already. This is why even the “stupidest” idea is enough to kickstart a small project for your portfolio.
But you should not just implement things that only showcase a particular feature of a language or framework you want to use. Instead of only implementing only a single function that models a trade on a decentralized marketplace, build the whole market.
When a hiring manager actually takes the time to look at your portfolio, they might get tempted to not look at the code but instead, try to see the finished product. If that product does not make sense at all, it definitely affects the hiring manager’s opinion.
Such a project that actually makes sense could be the foundation on which a whole interview can be based. You might end up talking about your marketplace all the time, and about the problems you faced and solved instead of answering generic technical questions.
Take care of everything from start to finish
This is another serious point you need to consider. Although there is this joke that many job listings nowadays require a whole IT department, the responsibilities of a software engineer have definitely grown in the last years.
Here are a few things that I would expect a good smart contract engineer to know besides coding:
- Project setup
- Project tooling
- Automated testing
- CI/CD overall
These are only the tip of the iceberg, but it’s nearly a hard requirement these days that engineers know these points, even beyond smart contract development.
Setting up projects, for example, is an often-overlooked task. Setting up a project is even one of the most challenging things in some ecosystems.
If you only work with super basic projects without adding linters, formatters, and all the other tools that make your life easier through automation, you’re missing out.
It’s thus super important for engineers to build their stack and be able to iterate on it quickly. The faster you can set up a project, and the better the tooling that comes with it, the better your results in the long run because you can focus on the really essential things of your job:
- Hunting bugs
- Finishing features
- Refactoring code
- Increasing maintainability
- and more
Automated testing is another crucial aspect of software development, and there is no way around it. If I see code that is not tested, even if someone tells me “I do it manually,” I automatically throw that project away in my head.
It’s just impossible to be relatively safe without proper tests that can run at any time. They should always be a top priority to give you the security to alwaxs make changes, without having to worry about consequences.
Deployment is yet another aspect of software development that is also often overlooked. The best software in the world is worth nothing if you cannot reliably deploy it to a place where users can actually, well, use it. This is why you need to take care of it and try to automate it to a point where it’s nearly effortless to get a new version to your users.
CI/CD is the combination of the previous points up to the extent that everything is automated. Learning it is nothing too easy, that’s for sure, but many teams need to take care of that these days.
Learning GitHub actions or GitLab CI is well worth the investment. And for your portfolio projects, that’s definitely more than enough. There are, of course, other tools out there that you could use, so just try to pick something that works for you. However, you must learn the concepts and mindset behind those tools and showcase that you understand and can apply them.
In the end, you should end with one and, even better multiple projects that probably don’t have the scope of a real-world project but contain precisely what you would expect from one. This is what really gives you the edge over other candidates, and once you know your way around it, it’s not as tricky anymore as it seemed at the beginning.
The positive effects of a portfolio of projects in Web 3
In Web 3, more than in “traditional” industries, projects can really make a huge difference. The space is more open overall, and it cares more for what you have previously achieved, even outside of your professional career. In the end, most talent comes from traditional backgrounds, and so Web 3 experience is often a little scarce. But open source and open portfolios are a great showcase of your potential.
If you ask yourself what you can build, take a look at the following article. I mentioned many standards there that all Web 3 developers should build at some point of their career.