I'm at the stage building my publishing server software where having a more defined plan makes sense. I've started using git tags and semantic versioning to plan out the next few releases. Each release happens in stages so you have times where you only have part of the feature set written but you still want a release to test, with uncompleted features behind feature gates. These are beta releases (e.g. 1.1.0-beta.1, 1.1.0-beta.2). Then when you have all the pieces ready you try to put it all together in a release candidate (e.g. 1.1.0-rc.1). Eventually when it's all working you drop the extra qualifiers and you are left with just the version number.
The core of the software is very solid, it basically never changes now, or if it does it's small tweaks. I haven't had to re-record the test fixtures in months. There are several layers that insulate the core business logic, both above it and below. It makes it much easier to change things in the frontend display, and in the backend storage. As well as the core, there are now several extension packages that you can add to get new features, and these layer ontop to create several distributions that work in different environments. There is an assembler that you use to build exactly what you want, with a particular feature set.
Since I'm working with all these packages, although it's a monorepo, the tagging works really well to co-ordinate all the PRs necessary for a release. Gives you something to aim for. When you list all the commits, you can see the ones that correspond to the releases. It really helps with how you think about the code, how you conceptualise what is still to do, and where you are at.
In the last few days I identified a crucial relationship in the core that needs to change slightly in order to move forward. As I was looking at the various distros I revisited an idea I had a while back, to unify all the route handlers. At the time it seemed too difficult, but now it looked possible. I was able to extract all the route handler logic across all the distributions into a core handlers package with the variations between distros neatly inside a thin layer in each distro. The complexity of all the distros has decreased significantly. And it was pretty easy updating the unit and integration tests.
I'm very well positioned now for the final push to make the small change in the core, necessary in order to get 2 very important features working. The world is so crazy at the minute, and I might not know exactly how I fit into it or what's going to happen next in my life, but I know that I'm pretty happy with where the publishing server and the rendering CLI are at. That's the thought what grounds my thinking most right now.