We often have grand ideas for projects and then easily get stuck at one of a few different stages. Often we have a huge list of features and balk at the size of the work involved with no idea of where to start. Or we start by building a single component with huge scale in mind and quickly get disheartened by the lack of progress towards the end goal. Or maybe even we built a tiny scale idea and then throw it away, not knowing how to turn it into what our visions demand.

These are all common and normal issues, I've had them repeatedly over the past 10 years, but I'm slowly overcoming them with recent work and I wanted to share my secrets and recommendations.

I'd recommend combining all the following ideas rather than taking them individually, as together they seem to blend quite well and are greater than the sum of their individual selves.

## Extensible MVP

One of the ideas I liked from my time working at [HealthEngine](https://healthengine.com.au/) was the concept of building an [MVP (Minimum Viable Product)](https://en.wikipedia.org/wiki/Minimum_viable_product). Something that encapsulates key parts of your idea, to the extent it's usable and can stand alone as a completed thing.

In the case of my [NS3000]({{< relref "/content/personal/2020-04-19-ns3000-file-storage-solution.md" >}}) project, I wanted something that could store and categorise images, extract metadata, perform OCR, and allow for searching.

There's a lot more I want to do, but that would give me a platform to work from. Of course, that's still a pretty lofty goal, so it made sense to...

## Stand On The Shoulders Of Giants

> If you want to build a car, you shouldn't have to smelt the ore that you'll use in the frame.

For complex components, consider using pre-existing work. If you're building a website, you shouldn't need to write a new operating system.

For my NS3000 project, I decided to use a bunch of frameworks and technologies to speed up parts of the development. These included:

* [Laravel](https://laravel.com/) - PHP web framework
* [Apache Tika](https://tika.apache.org/) - Metadata and content extraction
* [Xapiand](https://kronuz.io/Xapiand/) - Full-text search
* [Pillow](https://pillow.readthedocs.io/en/stable/) - Image handling in Python
* And a few other bits and pieces.

Of course, you want to be careful not to get too caught up in finding a package or library for the smallest pieces. You don't want to end up in a debacle like the [left-pad incident](https://www.theregister.co.uk/2016/03/23/npm_left_pad_chaos/) within the JavaScript community.

I'm not saying this is sacrosanct advice that should always be followed. There are some key examples where reinventing the wheel or being totally vertically integrated works well, such as [YKK zippers](https://slate.com/business/2012/04/ykk-zippers-why-so-many-designers-use-them.html). But if you're writing your own project, and you're not specifically trying to build something "from scratch", then take a look at what tools are already available.

## Some Agile Is Handy

There's a lot of good and bad advice and experiences about [Agile](https://en.wikipedia.org/wiki/Agile_software_development), but we can take small elements of what we want when building our own projects to do even better.

I find using a [Kanban](https://en.wikipedia.org/wiki/Kanban_board) board effective for tracking my tasks, and I can add more to it as I see fit. There are a few tools that are handy here. Many people recommend [Trello](https://trello.com/) but I'm partial to [Taiga](https://taiga.io/) because it also provides me project wikis where I can store extra information, goals, etc.

Breaking down from the MVP idea you can also create small components of work that can be delivered on a regular basis to help keep your motivation up. For my NS3000 MVP I broke it down into the following:

1. Web app with file uploads, tagging, and user-defined metadata
2. Automatic metadata and content extraction
3. Full-text search
4. Image thumbnails

This way I had a goal for each stage, and could work on delivering that quickly and efficiently before moving on to the next section. It also meant components had clearly delineated boundaries of what they needed to do. This helped break my application into composable parts and helped me understand how features would interact.

## Track Your Progress

The Kanban board is good, but I find writing down my progress also really handy. For NS3000 I used a small project planner with monthly and weekly views, checklists, and some writing space. At the start of the month, I added big ticket items to the checklists. Then each day I added my daily goals to the weekly view and ticked them off as I achieved them. At the end of the day I added them to the month. I ticked off the larger items as they were done and at the end of each week wrote a summary.

You can see a lot of duplication in this, but it also helped me strategise, work out my capacity, as well as plan rest days and focus days. It also meant that I was writing about what I had done, codifying my achievements and giving me a sense of progress and satisfaction.