small_avatar_AdrianR3.png

thumbnail_avatar_AdrianR3.png

avatar_AdrianR3.png

Adrian

GET IN TOUCH

During my career, I worked with many React.js teams and was involved in some way in dozens of projects. Over the years I feel I witnessed enough to say with a degree of certainty what is needed to build a well-functioning, technically precise, and efficient team.

Unsurprisingly, we follow many of those principles and practices at Bitnoise. While you can freely adapt some of them, a few come from past projects and attitudes which is difficult to emulate.

In any case, I hope the below summary will be an inspiration.

So what makes React.js teams truly special?

#### Experience
At Bitnoise, We’ve been part of the React.js journey since its beginning. When it was released in 2013, we already had years of experience in software development. Before the advent of this library, we worked with various technologies where we struggled trying to achieve user-friendly and efficient applications. However, we’re always looking for new technologies to help expedite our work and provide top-notch solutions using the best possible tools.

Over the past decade or so, we’ve watched React.js grow and evolve. Unfortunately, it has become bloated with multiple offshoot libraries making it rather clumsy to use. Consequently, a few challenger frameworks have emerged, including Vue.js.

Lately, we’ve been contented to see that React.js has become leaner, more efficient, and developer-friendly. We can thank the community and amazing frameworks such as Next.js and Remix.js for helping facilitate this change.

As for our role, it’s safe to say that after delivering dozens of software projects, building multiple frontend and full-stack teams, and speaking to hundreds of developers over the past decade, we know React.js inside-out. This technology bears few surprises to us.

Without this experience, we would not be able to build such good teams, and I doubt others would.

![ ](\uploads\Blog_artykul_PiotrB_React.js_blog01_1l87xFkyuQoNZiiA1pNBe0.jpg)
#### True engineering on the frontend
Typically, you might reserve the term “software engineer” for backend developers. And yet, this term fits front-end developers perfectly. It is not about the part of the application they work on or the technology they specialize in. Things like a degree in Computer Science or some other STEM subject are a great background for a great frontend engineer.

That’s why we tend to hire React.js developers with solid, relevant academic backgrounds. Furthermore, we have several backend and full-stack developers on our [team](https://www.bitnoise.pl/team)
. Node.js, Python, .NET, and PHP are just a few of the tools these developers work with. Whenever we work on a front-end project, our developers are always ready for consultation or ad-hoc work.

#### Pixel-perfect mentality
Being capable of expressing every imaginable design through code should be within reach of any good frontend team. To transform [clients](https://www.bitnoise.pl/clients)
’ blueprints into a reality, expert UX/UI designers should work hand in hand with developers. As a client, you can work with these designers one-on-one as they service your project. Otherwise, they should be available for consultations if you provide us with designs from an external agency.

In our case, part of our commitment to perfection comes in the form of our use of state-of-the-art tools for design and collaboration.

- **Figma** is a powerful cloud-based design collaboration tool. As such, it allows designers, product managers, owners, and developers to communicate and collaborate simultaneously. 

- **Storybook** is a workshop where developers can build frontend components and pages individually. This is useful because it enables us to demonstrate and check the component pieces of an application without needing to have the entire view or page ready at once. 

- **QA engineers** test all of the apps we build. At the bare minimum, we run our products through automated testing to ensure that the UX is excellent from day one. 


![ ](\uploads\Blog_artykul_PiotrB_React.js_blog02_1H7vOvuCMd7jNlJjqcps8H.jpg)
#### Bitbucket, Eslint, Next.js and Remix to complement React.js
Cutting edge projects usually take advantage of modern tools to complement React.js and streamline frontend work. As a result, high-quality software is created faster. Here are a few of the tools you might use:

- **Bitbucket/Vercel/Fly.io** for Continuous Development and Continuous Delivery (CI/CD). This toolkit helps us avoid long builds and unnecessarily complex configuration work. I.e., it relieves us of the typical mess and stress that comes with tedious development and QA processes. Furthermore, we like this combo because it provides collaboration tools alongside instant previews – thus leading to rapid iteration.  

- **Eslint/Prettier** for code quality. Linting tools analyze our code and look for errors within it. Since React.js does not have built-in compilers to check the validity and quality of our code, Eslint and Prettier are essential to our development process.   

- **Next.js** and **Remix** for a fast, slick UI. Using these two frameworks, we can optimize interactions even with the most intricate designs. They also help improve the developer experience while we’re coding thus making our jobs easier.  

- **React-Query, Redux-Toolkit, and styled-components** as libraries of our choice.


#### TypeScript
By using TypeScript on top of raw JavaScript, code becomes a lot more consistent. Of course, JavaScript is a scripted language, however, it does not use compilers. Therefore, it’s easy for developers to make errors while coding with it. TypeScript fixes this and makes code more maintainable in the process. Plus, it keeps code up to date with browsers as they change their standards.

Here are some of the many concrete benefits of using TypesScript:

- Increasing team performance

- Easier code management

- Early spotted bugs Increasing code readability

- Easily readable and understandable components


#### SEO mindset
Regrettably, raw React causes some issues with search engine optimization. Sometimes, search engine algorithms will shun pages built on React - especially if they’re a single-page application. We resolve this problem with Next.js. Since Next.js permits rendering React applications server-side, the SEO issue vanishes.

#### Community and knowledge sharing
Best teams are not the ones who become isolated from the rest of the world. Learning, teaching, talking to others, inspiring them, and helping others in the software community brings in a lot of new energy and motivation to developers.

In our case - the commitment to education is everlasting. We’re constantly investing in professional development and growth at every level. Here are some examples of our philosophy in action that may help your teams grow too:

- **Internal training**, which is directed and delivered by our senior developers or an external specialist.

- **Bitnoise Meet** is a learning initiative we began to encourage education and research in our field. In doing so, we invite professionals from other companies to learn alongside us.

- **PozTechTalks** is a series of podcasts and videocasts that we coordinate with other local software companies in Poznań. During these sessions, we discuss advanced computing concepts and challenge each other on our perspectives.

- **Land on Moon** is a meetup initiative where CEOs, founders, and product owners share their inside stories from the software development industry.




Blog_artykul_PiotrB_React.js_blog03.jpg

Blog_artykul_PiotrB_React.js_blog04.jpg

Blog_artykul_PiotrB_React.js_blog05.jpg

Bitnoise_events

I hope those hints will help your team become better and happier. If you’d like to work with me or my colleagues check out some of the services we offer and do not hesitate to reach out to us.

- [React.js teams](https://www.bitnoise.pl/services/remote-react-js-teams-next-js-typescript)
 

- [CTO as a Service](https://www.bitnoise.pl/services/cto-as-a-service)
 

- [Process consulting](https://www.bitnoise.pl/services/software-development-process-consulting)





small_Blog_artykul_PiotrB_React.js_blog_cover_high.png

thumbnail_Blog_artykul_PiotrB_React.js_blog_cover_high.png

Blog_artykul_PiotrB_React.js_blog_cover_high.png

What do best React.js teams have in common?

When I talk to CTOs, I often recommend React.js, which might come across as biased since I work for a company that uses it on a daily basis. However, I made a conscious decision to work in an environment that emphasizes React.js and have been actively encouraging its further adoption within the company. I firmly believe in technology and wouldn't work in an environment that doesn't align with my beliefs, which are outlined below.  React.js is undoubtedly the most widespread, popular, and sought-after frontend technology within the software development community. This alone should be reason enough to make it your go-to framework for frontend development. However, let's delve deeper and explore other reasons supporting this assertion.

#### **Why choosing the right frontend framework matters**
When embarking on a new project or updating an existing application, one of the most crucial decisions to make is the choice of frontend technology. This decision is critical because it has long-term implications for your product and work. In my experience, I have seen several products struggle because of poor past technology choices. Selecting the appropriate frontend technology is a daunting task since it affects not only what the technology does and how it functions but also who can operate with it and what other tools can enhance and augment it.

#### **The pragmatic case for React.js**
The React.js community is massive and its popularity is evident from various statistics. For instance, a search on LinkedIn reveals that over one million people worldwide have mentioned React.js in their profile, indicating some level of experience or interest in the technology. This is significantly more than any other frontend framework.  

The widespread popularity of React.js has two important implications. Firstly, it is relatively easier to find developers with React.js experience than with expertise in any other framework. Secondly, due to the high demand for React.js talent, there is significant competition among employers to hire them.  

At first glance, it may seem like these two facts offset each other when it comes to hiring. Although there are more candidates, there are also more job openings, which should balance the job market. However, the concept of liquidity comes into play, much like in the stock market or altcoin market. The more developers with specific skills that are available, the more likely they are to seek out new opportunities, making it easier to hire.  When considering the long-term perspective, the size and liquidity of the React.js community play a crucial role for both you and your HR team.

![ ](\uploads\Blog_artykul_Grzegorz_React.js_blog_01_1pVcCpqFPKCNby6LpN9XI1.png)
#### **Net talent flows to frameworks**
It's important to remember that today's statistics may not reflect tomorrow's. It's also essential to consider the dynamic nature of people changing their expectations and enhancing their skills. One significant realization I've had over the past few years is that no one wants to switch from React.js or Vue.js to Angular. However, switching in the opposite direction is relatively common.  

For example, a skilled Angular developer with a good understanding of project work, methodologies, and business needs may decide to make a career move and explore a new framework. They could take a React.js course, work on some TypeScript projects in their free time, and be ready for a new challenge in a React.js team within a few months.  

This scenario almost never occurs in the opposite direction. As a result, if you start a project in Angular today, you are more likely to lose your developers to React projects than vice versa.

#### **Avoiding hypes**
Every once in a while, we witness a hype around a particular technology. I remember the sudden rise of Vue.js around 5 years ago. Many developers were attracted to it, mainly because of its ease of use. I talked to several Angular developers and backend engineers who were interested in trying it out. CTOs also wanted to experiment and started their projects in Vue.js. It was an exciting time with good energy, and it was an opportunity for junior developers to become proficient in a particular framework quickly.  

However, as of early 2023, the hype has largely dissipated. Although the technology is still in use, being developed and improved, it hasn't caught up with React.js by any means. I can see some companies now stuck with Vue.js. Although it is easy to use and gets the job done, the talent pool for Vue.js projects is relatively limited.  

(It's also important to note that Vue.js is not very scalable. If your app is likely to grow, you may find it cumbersome to use this framework.)

#### **The case for mobile apps**
If you plan to turn your web app into a mobile app, React is an ideal option. You can use your existing React team to build a cross-platform app in React Native. This approach saves you from having to allocate additional resources and performing the same work twice for iOS and Android. It also maintains the cohesion of your team and makes it easier for developers to switch contexts, ultimately reducing the costs of maintenance.  

In my opinion, an experienced React.js web developer can build a mobile app relatively quickly, even if they lack prior mobile development experience.

#### **Summary**
Choosing the right frontend technology is critical for any project's success, and I recommend React.js due to its widespread popularity, large community, and ease of finding talent. The size and liquidity of the React.js community play a crucial role in both hiring and long-term maintenance. While hyped technologies may be attractive, it is essential to consider their scalability and talent pool before choosing them. React.js is also an ideal option for developing mobile apps, as an existing React team can easily build a cross-platform app in React Native, reducing costs and increasing team cohesion.




small_Blog_artykul_Grzegorz_React.js_blog_cover_high.png

thumbnail_Blog_artykul_Grzegorz_React.js_blog_cover_high.png

Blog_artykul_Grzegorz_React.js_blog_cover_high.png

Why do I recommend React.js as a frontend technology to CTOs?