Big features workflow and contributions

We would like to start talking about how to handle the development of big features, like the AMP package or the Server Extensibily, to improve the process and ensure it is reliable and anyone can jump in and collaborate with the Frontity team. This is the workflow we have currently in mind:

  1. Everyone can suggest a new feature and we will start discussing in the community if it makes sense and which functionalities and requirements should be covered.

  2. We will run a more in-depth analysis, to come up with a full list of potential functionalities and requirements that we should keep in mind while developing the feature. Even if we won’t include all the functionalities in the first version, it could be important for the design of the feature.

  3. Keeping in mind all the functionalities and requirements, we can run a technical research, that will end up in an Implementation Proposal following this template, and it will cover how we are going to approach the feature and which tasks are needed to release it. We will usually create first an initial draft of this Implementation Proposal, open it for feedback and ask some questions that aren’t clear. Once we consider we have enough feedback and there aren’t more questions, we will write the final Implementation Proposal.

    A good example of this could be the Server Extensibility feature: We created an Implementation Proposal draft with some open questions, and later we created the final Implementation Proposal.

  4. Once the Implementation Proposal is done, we will move the different tasks defined there to a GitHub board. We will create issues that could be address independently, and we will use the board to check the progress. We will use Pull Requests for each issue and the Frontity team will review them. At this point, in some cases, we could jump into ad-hoc calls if necessary.

    Again, we could take a look at the Server Extensibility board as an example.

  5. We will do a release of the new feature once all the issues are closed and we will write down in the Feature Discussion the Final Implementation following this template, where we will explain how the feature was finally implemented and how to use it. We will usually create a demo showing it. Anyone reading this Final Implementation post should be able to understand how it works and how to configure it.

  6. With the Final Implementation written, we will open an issue in the Frontity docs repository to let the team know that this could be address.

Note that each step, except the development of the issues where we will use GitHub, will take place in the Feature Discussion in the forum.

Regarding how to cooperate with contributors, I would say anyone could jump into any of these steps at any point. Some things they could do that come to my mind:

  • Ask us to lead the full process of one of the features.
  • Ask to lead the different research phases.
  • Ask to lead the development once the research is done.
  • Address any of the issues that are included in the GitHub board.
  • Just give feedback and test the different functionalities.
  • Take care of the documentation once the feature is released.

This is a diagram showing the full process:,Mx-XUAtT9nNjKKXd3yu9ZQ

Thanks @santosguillamot :+1::slightly_smiling_face:

Thanks for documenting this, it adds a lot more clarity to external contributors.