In order to build and deploy killer-feature enterprise web apps in 2021, there are a number of factors to take into account. This blog will highlight important team dynamics, technologies and practices that will aid any team in increasing their productivity, allowing them to deliver delightful apps to their users.
The main factors can be summarized as follows:
Have a solid team.
Choose a serverless tech stack.
Use A-list engineering practices.
Build accessible apps.
My dream team consists of the members listed below (in no particular order of importance). Even more important than the individuals, however, is the synergy between them. The Project Manager should nurture a culture of collaboration and open channels of communications between members (especially as teams are working more and more remotely than ever before). Most likely in reality all of these roles won't be filled, and one person might wear multiple hats, but I believe better quality products are delivered if individuals can take ownership of their field of expertise and excel there.
Project Manager.
Business Analyst(s).
Architect/Tech Lead.
Software Engineers for Front End, Integration and Back End (as it makes sense for the type of application).
User Experience Designer.
QA Engineer(s).
In the 2010s we have been witnessing a shift in enterprise applications from monolithic behemoths towards micro-services architectures, and now we are seeing the next shift towards serverless architectures.
My recommendations for enterprise stacks in 2021 are as follows, and the underlying theme is to aim for a serverless architecture - this won't be achievable overnight, but should be part of any organization's roadmap.
Front End
Use React and TypeScript, and at least SASS. From my experience, the UI framework (e.g. Bootstrap or MaterialUI) is playing a smaller role nowadays, and my recommendation is to opt for the plugins you need, rather than adopting entire frameworks and only using one or two features of the component.
Integration
Switching this layer at an enterprise scale is not quick or easy, but my recommendation is to consider the migration to AWS Lambdas, as it is a much more cost-effective to pay for usage than paying per application server - of course, this is not always true and the two approaches need to be weighed up against each other.
Back End
Systems of records remain mostly the same in 2021, if there is anything exciting I need to be aware of, feel free to leave a comment!
My current thoughts about solid engineering practices is as follows (this is particularly geared towards the front end, but is applicable to integration development as well).
The application should be architected correctly from the get-go, and should be periodically reviewed (without going back to the drawing board as that will take too much time).
Write unit tests from the beginning.
Enforce strict type checking with TypeScript - using "any" defeats the entire purpose!
Extract common components as soon as possible, and publish it to NPM - don't even think about copy/pasting!
Code reviews - at least one architectural review in the beginning of the project by the Architect, and a code review with each Pull Request by a peer. Check all of the items above in code reviews.
It is such an important concept ignored too often, and when it's not ignored it's only done for the sake of compliance. Accessibility is easier to get right than most people think - and one of the most important factors for front end engineers to consider and get right in 2021. The key, in my opinion, is to use semantic HTML, create basic components and ensure it's accessible as it is created, and as part of validating the the user experience, make sure the application can be used by only using the keyboard, and by screen readers.