Product Deployment Platforms
What are the expectations of the project? This is an important indicator of tech stack selection and a question to ask during the requirement planning phase. Without understanding of what you expect from the project, choosing a stack is a futile move. You should ask the question(s) of how/when/where your target audience will use your product. These questions would allow you to determine which platforms you are going to deploy your product on e.g., on a web-based system, on mobile devices or both platforms together.
For instance, a web-based project requires a different set of frameworks from a mobile application. Even within mobile applications, tech stack you need for Android and iOS development are different.
Project Types
Next you will have to consider the project based on its size, complexity, processing strength, goals, and timeline.
Small Projects
Small projects are usually fast to deliver due to simple requirements and usually can be implemented with less sophisticated technologies.
An example tech stack of choice for small web-based projects would be WordPress with dedicated plugins.
Mid-Size Projects
For mid-size projects, there is a higher level of technological commitment. These projects may call for the use of several combinations of programming languages and tools depending on requirements and platforms. Such projects require technologies that provide more sophisticated and diverse functionalities and integrations.
Complex Projects
Complex projects are just like the case of mid-size projects but with more complex features. You need several functions, integrations, and more sophistication, hence, your tech stack must be of a high level.
In addition, complex projects usually have stricter scalability requirements. Your choice of tech stack for scalability must cover horizontal scaling which involves several application servers running at the same time to handle the flow of user traffic, as well as vertical scaling for the inclusion of more programs to process new data types.
Criterion
Availability of Documentation and Community
Documentation is crucial to developers regardless of experience. With the help of good documentation, novice developers can easily learn and apply the technologies and experienced developers can identify and resolve usage issues quickly.
A good documentation should be concise and simple while making users aware of the product features and usages. It should container examples/demos to illustrate the best practices of applying the technology, which allows developers to replicate while avoiding as many issues as possible.
In addition, community support is a great alternative to documentation. There might be some common issues affecting developers everywhere and someone might have provided (official) solutions to those issues which allow developers to resolve those similar issues quickly. Project owners’ engagement with the community is a good indication of the amount of community support you will get in the future. For open-source frameworks, there should also be a set of strict guidelines and rules for other developers when providing solutions or implementing new changes to the frameworks.
Scalability and Updates
The project owners provide constant updates to frameworks while maintaining good security practice in usage. The framework should ideally be scalable in the future, that is allowing different integration or customization. One example that is for UI components framework, it should ideally allow developers to apply those components in different devices (web or mobile).
Rule of Thumb
Use frameworks that fit your project budget. Budget in this context means your team expertise, that is developers’ familiarities and preferences towards certain frameworks and tools. How much time do you have in the project timeline for developers to learn a new/complex framework? There are different frameworks with different level of complexity while providing similar functionalities and allowing you to implement your product features. If a project is highly time-critical, choose more intuitive frameworks so developers can easily learn on-the-go and build a functional product, as well as providing proper maintenance support to the product.