The Science of Project Planning - Part 2

“Strategy without tactics is the slowest route to victory. Tactics without strategy is the noise before defeat.” — Sun Tzu

The first post in this mini-series went over both a generalised and
developer-specific outlook of planning a project.
This post applies methods that I use in particular when piecing together ideas for code and will be in reference to my final Flatiron project.


Coming up with the right idea is where the real heart of the vision lies. You want to make sure your idea is both viable and possible with the resources at hand otherwise you are bound to fail in its execution, no pressure.
Let’s look at how this process can be approached.

Is there a gap in the market?— This is how most ideas start in business, and this applies to development as well. It all starts with a foundation that’s either hard to find elsewhere or has plenty of room for improvement.
You can also find a good starting point by finding a problem either generalised or personal and making your project the solution to said problem.

Consider the scope — This aspect has two sides. One of which is how grand in scale is the idea? You have to be realistic here and not attempt to solo a project that would benefit better from a team-based approach and vice versa. The other of which is that 99% of dev projects will need more work to carry on the flame after the first version / M.V.P is completed, hence part of the reason we are called developers. Keep that in mind when assembling ideas.

Directing the vision — This is where you will start to piece together the ingredients of the idea so it all makes sense and has it’s own direction. If you do this well, you’ll find moments when the idea even directs itself.
How would you categorise your app? What frameworks and libraries might you need? What features are essential and should be prioritised?
As you can see, depending on the scope of your idea, a lot of thought will need to go in to this aspect of brainstorming but you don’t have to write it all down. Provided that the vision is clearly defined, it can end up working itself out.

The Breakdown

From this point on, I’ll apply the previous concepts to my final Flatiron project. We’ll start with the third point from above seeing as it combines all the other concepts as well. First let’s look at an app breakdown template that I swear by, feel free to use this with your own projects.

  • Aim
    Outline the vision and intentions behind your idea. This should only be a short bio describing what the general direction of your project is.
  • Data Models / Entities
    Each app will have it’s own outline of related data. For instance, in a To-Do List app you may have a model for Users and a model for the To-Do Items.
  • Main Features
    These are the bread and butter macro-functions of your app that help it commit to it’s aim.
  • User Stories
    From an app user’s point of view, describe what is possible with the app and what the flow of usage may look like.
    It should be described like this:
    - A user can create a To-Do Item
    - A user can edit a To-Do Item
  • Stretch Goals
    After completing your MVP and your main features as well as successfully implementing all the possible user stories, what new features can you add to upgrade the capabilities of your app? (This is prone to change)
  • Considerations
    Mention any parts of the project that:
    - Needs to be prioritised
    - May be difficult to implement or requires extra attention
    - Is dependant on a library or module

    (This is prone to change)
  • M.V.P (Minimum Viable Product)
    Last but not least is our M.V.P and I don’t mean the most valued player, quite the opposite actually. The minimum viable product is the bare bones build of your app that includes only the most necessary aspects and features required to commit to it’s aim, essentially amounting to your first completed version.
  • -optional- Concerns
    Here is where you would detail any problems you are currently having with your project and need to be addressed, some devs prefer to have this section in separate file within their codebase, the choice is yours.

Welcome to MotiveRate

Image for post
Image for post
Image for post
Image for post
I made this design draft in Figma. While my website never actually ended up looking like this, it was pretty close so I definitely recommend sketching out a simple UI interface to help you stick to a design for your app.

Below is a condensed plan for my MotiveRate App.​


A single page app with the capabilities to make goals that improve personal motivation. There is also the ability to earn points through completing your actions and receiving support from peers.

There will be a focus on strong UI / UX integrations to facilitate better use of the app.

Main Features

  • Goal Creation
  • Sharing updates on completed goals
  • Currently trending key words and categories
  • Points system
  • Providing support to other members goals
  • Mobile-Friendly

​Stretch Goals

  1. Image Viewer
  2. Keeping notes on current goals (private)
  3. Events and Calendar Scheduling
  4. Gratification / Rewards for Goals (avatars, themes, awards, etc)
  5. Share on Facebook / Twitter



  • id
  • username
  • password
  • email
  • first name
  • last name
  • score


  • id
  • title
  • description
  • category
  • deadline
  • isCompleted
  • User_id |ƒ| (the ‘f’ stands for foreign key)
  • isArchived


  • id
  • text
  • supporters
  • User_id |ƒ|
  • Goal_id |ƒ|

User Stories

  1. Can create and edit account details
  2. Can create and edit personal goals
  3. Can earn points for completions
  4. Can share and edit updates in relation to goals
  5. Can support another user’s completions and updates with extra points
  6. Can archive goals and related updates


  • Updates / Experiences are ways for users to share their stories and completions as well as receive extra points from other users
  • Will likely use MaterializeUI library with react
  • Seed Profiles:

“Mangamojo” — manga artist
“culinature” — chef
Miasma” — DJ
NorthernLight” — Director
inFinityAdVenturer” — World Traveller
Kimpossible” — Novellist
AzirInn” — Property Management and Development
MartialSoul” — Martial Artist and Stunt Double
WyvernTech “— Application Security Specialist
Serenathena “— eSports gamer


  1. Rails backend API with a postgreSQL database. Each model has its own designated API endpoint and relationships between models can be easily distinguished
  2. 10 users, 10 goals and 12 updates as seed data
  3. Set up basic frontend built on react + redux that can receive data from back end API
  4. Home page / landing page
  5. User page that displays your dashboard / profile for organising your data
  6. CRUD functionality for users, goals and updates
  7. Intuitive points system
  8. Professional styling with strong UI / UX layout
  9. Publicised updates through users sharing experiences and completions


  • Delay when passing down state to profile component. Profile component doesn’t re-update without a refresh (no need to fix unless rendering profile immediately after log in / sign up)
  • Need the ability to individually select what to edit (user)

Wrapping up

I believe that the concepts introduced here are really all you need to make the best start possible and commit to the ideas behind your projects.
More detailed templates and action plans exist depending on the companies and teams you work with, it’s up to you to adapt your style of strategy and tactics to the methods of your work environment.
This concludes my mini-series for ‘The Science of Project Planning’

Now there’s no time to waste, get to it and good luck :]

— Code in Peace

An inquisitive programmer with a strong passion for Music and Technology. Building creative and intuitive code that hopefully doesn’t destroy anything :]

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store