I would suggest writing it this time as a large program with a bunch of subroutines, BUT try to group your subroutines together in a logical fashion with clear separators between the sections that you come up with. Try to make each function make sense on its own, and limit how much functions in each section call functions in the other sections.

There are several reasons that I suggest this. The most important is that recognizing design elements requires some experience. If you are not in the habit of writing modules, then you probably lack that skill and can spend a lot of time thrashing about without making much progress. However you probably can more easily write functions and after the fact recognize somewhat natural divisions. Focussing on writing loosely coupled functions will make it likely that natural divisions can more easily be recognized. If the result turns out well, you can then try moving some of those sections into modules after the fact.

The process of trying to reflect on the result afterwards should help develop some of the design skills that you will need in the future to modularize up front. But not facing that in addition to everything else that you change will make the first attempt more likely to succeed.

Or so goes my theory... (Good luck!)