2/3 PLG Engineering Leader Insights: Choosing Technology Stack, and its impact on attracting top engineering talent

Balancing Frameworks, Talent, and Product Vision for Optimal Growth.

In our previous blog - Balancing Speed and Precision in Product Development, we embarked on an exploration of the diverse strategies that shape the landscape of product development in the startup world. We threaded these strategies together, revealing the compass that directs startups toward successful product creation.

Now, shifting gears, let's delve into another crucial aspect.

When developing a product, the selection of the right frameworks plays a pivotal role in ensuring the product's long-term success and scalability. The choice of frameworks can significantly influence the product's architecture, feature set, and overall user experience. 

One of the key aspects to consider when selecting frameworks is their ability to support the product's long-term vision and scalability. This implies that even if all features are not built out from day one, the chosen framework should be able to accommodate these enhancements in the future. This is particularly crucial when designing a system that needs to support different levels of capabilities or access, such as a freemium to a paid subscription model. 

Today, there are numerous frameworks available, each with its strengths and weaknesses. The choice largely depends on the specific needs of the product. For instance, some frameworks may be more suited for feature flagging like LaunchDarkly- enabling or disabling certain features for different users. This could be particularly useful in a SaaS product with varying levels of user entitlements. 

However, it's important to note that the selection of a technology stack and framework is not just a technical decision but also a strategic one. It's closely tied to the kind of talent the startup is looking to hire.

The Importance of Framework Selection in Product Development

Ensures Long-term Success: The right framework can ensure the product's scalability and longevity. Let’s consider React Native vs Flutter. One may choose React Native if you prioritize a larger developer community and easier integration with existing JavaScript projects. On the other hand, a team with Flutter experience can deliver a consistent UI from a single codebase for Web, iOS and Android. The important factors here are team expertise, project requirements, and ecosystem support when making your decision. A well-architected monolith with well-structured code might be more suitable when designing a simple application or prototype. But If you go with a distributed environment, microservices can serve the purpose in the longer run for scale.

Influences Design & UX: The choice of a tech stack can significantly influence design and user experience (UX). For example, using JavaScript and React for a web application can enable capabilities for smooth animations (performance), responsive design, real-time updates, and interactive features. This choice directly affects how users engage with the application, making it seamless and engaging while maintaining code quality for design iterations.

In complex scenarios such as micro frontends, where multiple autonomous teams collaborate to build different sections of a web app, the need for concurrent work becomes crucial. This architectural approach divides the user interface into smaller parts, enabling large teams to focus on specific features, expediting development and deployment.

Supports Future Enhancements: Frameworks should be flexible to support future iterations. Software systems change rapidly as product requirements evolve. The less prescriptive and more modular a framework is, the easier it can be adapted to your evolving software product. When making a decision to enable flexibility on the API layer, engineers are opting for a GraphQL layer. REST API contracts are strict, and if there is a change, both the client and the API must agree on the change before it can be implemented. Otherwise the API needs to provide backwards compatibility and support versioning. REST is still relevant, and is still commonplace today, but many modern applications composed of a front end client consuming a backend API, GraphQL has been a benefit.

Choosing the right tech stack

It's important to note picking the right tech stack isn't just a technical choice – it's strategic. It's tied to the talent your startup wants to bring in. The technologies you use can attract specific types of talent. Say you choose React over Angular – both great frameworks, not one better than the other. But they resonate with different developer groups.

Engineers often seek chances to work with specific technologies, boosting their skills. For startups, risks exist, but if engineers spot the chance to dive into the tech they're passionate about, risk can fade against opportunity. Also, your tech stack and attracted talent shape your development timeline.

Remember, your tech pick affects not only your product but also the team you're building.

Here are some pointers to help you make an informed decision:

💡Deciding between Microservice and Monolith

Team Proficiency: Your development team's expertise plays a crucial role in determining the right tech stack. Leveraging technologies that your team is already familiar with, like Python for data science or Golang for high-concurrency applications, can significantly expedite the development process. For instance, while some may argue that Python or Ruby are slower compared to other languages, their performance is sufficient for applications that don't require ultra-low latency or high throughput.

Scalability: The term "scalability" often gets thrown around, but it's essential to define it in the context of your project. Different tools handle various scalability requirements. For instance, a framework that handles 1000 requests per second for static data isn't the same as one that serves dynamic content from a database. Beware of tutorials showcasing extreme scale under specific conditions; real-world scalability depends on internal factors more than external validations.

💡Choosing the Right Cloud and Staying Vendor Agnostic

Community Support:  When considering which cloud services to use, opt for those that are simple to implement. If your team has experience with them, even better. It is important to be mindful of vendor lock in, however, if you are considering migrating from one vendor to another there should be a strong value proposition behind it. Even if your tech is cloud agnostic, it is still work to lift and shift to a new platform. You have to balance the benefits and risks of time to market. Building on top of proven cloud technologies, even if it creates some form of vendor lock in, can potentially accelerate your time to market. As an example, every major cloud provider has some form of file storage. AWS has S3 and Google has Cloud Storage. Depending on which platform you are on you will have some dependency on said service. There is a balance to being cloud agnostic and cloud dependent and it will have a direct impact on your speed to market. Another example is ElasticSearch on AWS. AWS forked ElasticSearch open source and created OpenSearch. It’s not as powerful as ElasticSearch, and locks you in to AWS. It gets the job done, but you may require more of the value that Elastic can provide as new updates and features come out. When choosing between major cloud providers like AWS, Azure, and GCP, keep in mind the benefits and challenges each platform brings.

Open Source Advantage:  Open source tech stacks often provide an edge due to their extensive communities and developer resources. Not only can you tap into community contributions, but you're likely to find skilled engineers who are familiar with these tools. As with any open source tool, you will need to stay on top of security patches and be aware of any vulnerabilities that exist. Open source is a double edged sword in that respect. Being that it’s open, if the community is big enough they can identify and patch issues quicker. However, if there is limited community support and an exploit is created, it could take time to identify and patch, exposing risk to your business.

💡 Prioritizing Documentation and Ease of Use

Comprehensive Documentation: Frameworks with thorough and well-maintained documentation are your allies. Clear documentation facilitates ease of use and contributes to the creation of high-quality software. Take ReactJS and Angular, for example. Their well-written documentation not only simplifies the integration process but also eases the onboarding of new team members, leading to faster development cycles.

💡 Choosing Right Databases 

A complex web framework in a complex language that can handle 500,000 “hello world” requests per second, when connected to a database that can only handle 1000 queries per second, can then only handle 1000 requests per second. If this database bottleneck cannot be improved, might as well use a simpler framework with less throughput to make life easy. It is important to understand the global bottlenecks, which almost always are databases, before making fine-grained optimizations and decisions. If the Engineer in the team only knows about using <insert-framework-here>, this problem can take down the whole of your application.

Remember, your choices today set the stage for your project's success. As we wrap up this chapter, stay tuned for the third and final blog in the Engineering Insight series.