small_avatar_AdrianR3.png

thumbnail_avatar_AdrianR3.png

avatar_AdrianR3.png

Adrian

GET IN TOUCH

Introverts and extroverts work at Bitnoise. Those who need warmth to be happy and those for whom it is always too hot. There are those who live only for coffee and those who are better avoided before their first coffee;) Bitnoise means people who can be heard all over the office, even though their room is far away from yours. But they are also calm souls who wonderfully materialize when we order lunch. Bitnoise means tireless ping-pong players and partners for long, interesting conversations in the kitchen.


But most importantly, Bitnoise is a tight-knit team that loves to spend time together!
Based on who we are and what is important to us, we have created gadgets for our 13th birthday!


Our values were captured in an animal version by Marta Szymańska, and our designer, Łukasz Berliński, added some Bitnoise character.



1.jpeg

2.jpeg

3.jpeg

4.jpeg

5.jpeg

6.jpeg

7.jpeg

8.jpeg

9.jpeg

Bitnoise gadżety 2022

small_Blog_artykul_BitnoiseKit2022_cover_high.png

thumbnail_Blog_artykul_BitnoiseKit2022_cover_high.png

Blog_artykul_BitnoiseKit2022_cover_high.png

Bitnoise Kit - 2022 Edition

Frontend Engineering

UX/UI Design

Research & Discovery

AI For Your Business

Services

Case Studies

Career

About us

Blog

On the last weekend of May, we celebrated our 13th birthday! On the one hand, we have the impression that we have known and worked with each other forever, but on the other, we cannot believe that so much time has passed!
This year's celebration was inspired by our values, and our integration trip greatly reflected them.

Here's how these 13 years were summed up by the founders of Bitnoise, Adrian Roth and Lukasz Roth:

“Bitnoise means technology enthusiasts who constantly develop. It means countless conversations at the coffee machine and an initiative that we all take. It means responsibility for your work and your team, but also our parties until dawn and board games battlefields. It means taking care of what we represent and having a willingness to help - on a professional and friendly level. Bitnoise means our passions, discussions and laughs.
Having built Bitnoise for 13 years, we believe in:
partnership, agency, expertise, development, intellectual courage, ownership, harmony and a safe place. "

We wish ourselves many more great years together!



Blog_artykul_13thBirthday_cover_high.png

1654515354475.jpeg

1654515357372.jpeg

1654515356248.jpeg

1654515352661.jpeg

1654515350540.jpeg

1654515352017.jpeg

13 urodziny Bitnoise 

small_Blog_artykul_13thBirthday_cover_high.png

thumbnail_Blog_artykul_13thBirthday_cover_high.png

Bitnoise's 13th birthday

Adam Misiorny is a Frontend Engineer and Tech Lead at Bitnoise. Since Adam is one of the most experienced software developers on our team, we thought he would be the perfect person to offer insight into how our different developers cooperate during their work.

#### You are a leader, but what exactly is your role in your current project?
At the moment, I’m a Frontend Principal Engineer in a long-term project with JOIN. This means I have the most detailed knowledge of the project and the associated systems. As a result, I’m the one who makes decisions regarding development directions and front-end architecture. It’s a big responsibility. Sometimes, I work on developing the platform itself, but mostly, I’m in a leadership role.

From the perspective of the front-end developers working alongside me, my task is to accelerate product development and render it as efficient as possible. Since I am tasked with ensuring efficiency, I also get in the trenches and help solve complex problems should the situation require it. I’m always of use to other developers.

#### As a Frontend Principal Engineer, do you take part in onboarding new developers at Bitnoise?
Indeed, I often introduce new developers to the project. I take an active role so that each developer can get started working on our products quickly and eliminate onboarding uptake time.

Part of this onboarding task is to acquaint developers with our application architecture and coding standards. This helps light the path forward for quality work to get done. Under my watch, developers familiarize themselves with the common processes we use with each project. These range from pull requests to production deployment.

#### And how do you work with new developers in the project?
I assign each of my junior and middle-tier developers a senior “coding buddy” who assists them with their daily tasks if necessary. As the Principal, I supervise the developers at the review stage with an emphasis on the initial stages to ensure that we set the right tone. Should any of my developers have an inquiry, I am quick to answer them and assuage their doubts.

My role as a consultant is one of the most critical parts of my job. I need to give every developer context as to why we approach each problem a certain way. Less experienced developers soon absorb our general programming ethos at Bitnoise as a result. Understanding is the key to growth.

![ ](\uploads\Blog_artykul_Adam_React.js_02_BZ72URItqw8KOX2g07eZS.jpg)
#### What surprises you about working with less experienced developers? What attitude do you expect from juniors and mids?
While I am usually busy shepherding young developers, it’s not uncommon for me to learn a thing or two from them myself. My experience is a major asset, but that can sometimes mean that my programming approach is rather fixed. I benefit quite a bit when I receive fresh perspectives from young computer science graduates. Our work is enriched when I can look at an issue from a different angle.

Above all, I prize developers who have a passion for learning. Anyone who hungers for knowledge can be taught anything, making them more adaptable as programmers. It’s no use trying to force-feed solutions to a disinterested developer. You can lead a horse to water, but you can’t make it drink.

#### What keeps you in Bitnoise for so many years? If I'm not mistaken, this year we'll be celebrating your 10th anniversary at Bitnoise!
It’s a fantastic atmosphere. Isn’t it? After 9 years of working here, I still haven’t tired of my role. And I’ve grown along with it. Even as Bitnoise has evolved and grown, the team spirit has never changed.

When I was a young programmer, I worked on several projects with diverse topics. Consequently, my breadth of programming knowledge skyrocketed, and today I am happy to say that I have experience that ranges the entire spectrum of software development.  Once Bitnoise assigned me as the leader of a long-term project, I appreciated the new stability. It felt as though I had been preparing for years for this role given my work in so many different fields. After 4 years of working with JOIN, I still haven’t grown bored of the project – it keeps me on my toes as I learn new ways to solve the problems we encounter.

If you’re looking to work for a stable company where you can grow your programming skills, I highly recommend working at Bitnoise. The atmosphere is, as I said, top-notch. Personal development is a priority for all of us.



small_Blog_artykul_Adam_React.js_cover_high.png

thumbnail_Blog_artykul_Adam_React.js_cover_high.png

Blog_artykul_Adam_React.js_cover_high.png

How do mid and senior React.js developers cooperate at Bitnoise?

Tech companies, including Bitnoise, thrive on the success of their clients. When starting a new project or enhancing existing ones, our focus should always be to deliver high-quality services within a reasonable time frame, especially in React.js-driven projects. 

At our company, we have a strong commitment to our clients and prefer to establish long-term relationships with them. Hence, setting a high standard for product quality and ensuring that we meet these standards by implementing our philosophy throughout the organization is a must. Communication, accountability, and timely delivery are all integral to customer experience. We believe that by following these standards, is a path of consistently delivering the best possible work to our clients.  

Here are the 8 pillars of quality in further detail.

#### **1. Excellence Over Quantity**
While growth is an crucial aspect of any tech endeavor, it is important to understand that business goals should never supersede our commitment to quality. This commitment allowed companies like Biitnoise to develop a sparkling reputation in the first place. As a result, there is a need to be extremely careful during the hiring process so that it ends with bringing in **the best talent**. We should not be blinded by our desire for growth and take on projects our team can’t handle. In Bitnoise, most candidates we interview do not meet the caliber we expect in our organization. Thus, we turn them away.

Furthermore, it is important that developers work with confidence knowing that they have support systems behind them. The assistance of CTO and head of technology during the development process ensure that they receive support or guidance where needed. Realistically, no developer is infallible.

In Bitnoise, collectively, our team has a deep pool of knowledge. Our developers are always welcome to consult with one another when they need advice on how to solve a problem.

#### **2. Responsibility**
When working with clients, the **full ownership** of the product in development is a highly desirable feature. This is not so common in our industry, but it goes to show you just how committed the tech company is to delivering quality work for clients.

In Bitnoise we want to be there both for the scaling and the building of the software to watch the company evolve. Several of our clients have worked with us for over a decade. We're in it for the long run.

The secret is, instead of outsourcing developers, we focus on developing an internal culture of accountability. As a result, we partner with companies worldwide to service their technology needs.

#### **3. Working Globally, Coding Locally**
Many prominent tech companies have clients sprinkled throughout some of the world’s top global innovation hubs, ranging from Berlin to London to Silicon Valley, but still they prefer to work as a team at home.

In Bitnoise, we are located entirely in Poland. Most of the time, we all work at our office in Poznan even though we have the option of working from home.

The main advantage of this kind of setup is that since **we’re located within the EU**, we can all benefit from their legal framework, and our clients can expect stability when they work with us.

#### **4. Stable Teams With Low Turnover**
The software industry can be extremely chaotic, and its job market is always competitive. To build a stable team, you must have an attractive offer and a positive work environment that incentivizes everyone to stay on board.

![ ](\uploads\blog-Quality2_28l1PL2QiWf1AAmOJrGjkO.jpg)
By managing our employees sensibly without being overbearing, we’re able to win their respect. A good idea is to foster a **culture of independence** in organization and endeavor to exercise common sense in all situations.

As a consequence, the team can develop a level of stability that might make some of the competition jealous.  

In Bitnoise few of our engineers have worked with us for 8 years or more, and it is all thanks to an internal culture of independence, knowledge development and trust.

#### **5. A Holistic Approach**
In pursuit of quality a specialization is a very important feature, but it can not overshadow other technologies. For example in Bitnoisie we are a **React.js-driven company**, and you might assume that we only build frontends. But it is not the whole picture. We’re extremely competent with back-end technologies including Node.js, Python, and PHP. A large portion of our engineers are specialists in specific areas of technology. However, we also employ full-stack developers who can work on a project from start to finish.  

Some of our core competencies include UX/UI, quality assurance, and project management. So you know we’re a team that can excel at any aspect of app development.

#### **6. Seniority And Maturity** 
It's impossible to run a software development company without employing and training junior developers but what makes a difference is seniority. For our part, we emphasize **seniority** as much as we can. The majority of our developers at Bitnoise have over 7 years of industry experience. In some cases, they have worked with multiple tech stacks. Moreover, our developers usually have an educational background in Computer Science or a STEM field.   

As a result of their experience and education, our clients reap the benefits in the form of Quality Audits, Consulting and Strategy services, and CTO as a service. This variety is unique among software development companies.  

#### **7. Transparency**
Clients in many cases place their faith in companies whose fee structure is clear and simple. In Bitnoise we charge hourly or daily fees and validate our work on the invoice with corresponding timesheets. We don’t charge any upfront fees, recruitment costs, or any other cost that might arise during our work. In the case of a fixed-price project, we agree on a maximum fee from the beginning of the project so there won't be any unpleasant surprises down the road. Rest assured that you will get what you pay for.  

Even though we involve project managers in our work, our clients still have **direct contact with our developers** and often collaborate with them. There won’t be any middleman mediating your communication. Moreover, our entire management team is approachable in case you have any inquiries. Feel free to reach out to us.

#### **8. Fostering A Community**
To encourage growth and education in our industry, we made it our mission to build a thriving community of software developers. In doing so, we’ve founded or participated in several software initiatives such as: 

[<u>**Land On Moon**</u>](https://www.landonmoon.co/)
 – a series of Berlin meetups for founders, CEOs, and product managers to discuss their experiences with one another and inspire startup leaders and other businesses that are attempting to scale. 

[**PozTechTalks**](https://www.youtube.com/watch?v=zZB5qCQg9go&list=PL7zHBa_5KmnLSaEp4qQLNPCmm1SuUpEsl&ab_channel=Bitnoise)
 – an educational initiative where leading software companies based in Poznan promote engineering and development quality. 

[**ITCorner**](https://itcorner.org.pl/)
 – Poland’s most prominent software development business association made up of like-minded IT companies. 

[**Bitnoise Meet**](https://www.youtube.com/watch?v=AfCA-2nzN4A&list=PL7zHBa_5KmnJxiilc9bvKt48J3wHxsNw3&ab_channel=Bitnoise)
 – in which our in-house developers meet together to train and enhance their programming skills.

**These are the 8 pillars of quality in software development:** 

1. Excellence Over Quantity 

2. Responsibility 

3. Working Globally, Coding Locally 

4. Stable Teams With Low Turnover 

5. A Holistic Approach 

6. Seniority And Maturity  

7. Transparency 

8. Fostering A Community  


Of course, there is more to this topic, and we eagerly look forward to discussing it with you if you have any questions or suggestions. Reach out to us at hi@bitnoise.pl, and let's have a talk.



small_blog-8pillarsOfQuality_cover_cover_high.png

thumbnail_blog-8pillarsOfQuality_cover_cover_high.png

blog-8pillarsOfQuality_cover_cover_high.png

The 8 pillars of quality of a React.js project

#### **Why do you need automation?**
 When working on a new feature, improvement, or bug fix, it is crucial to ensure that all changes adhere to the rules specified by the linting tools, such as [ESLint](https://eslint.org/)
 and/or [prettier](https://prettier.io/)
. Similarly, it is essential to run tests whenever changes are made to guarantee that there are no regressions.

 With a simple project setup utilizing ESLint for linting, and [jest](https://jestjs.io/)
 and [cypress ](https://www.cypress.io/)
for testing, at some point, you will need to execute the  following command:



 This is a lot to remember and as the project grows there can be more commands to run.  It can become annoying and repetitive really fast to run all of these commands by hand. Moreover, forgetting to run some of them can cause production builds to fail or introduce bugs that could’ve been easily avoided by executing these commands locally.

 It can become quite challenging to remember and manage all of these  commands, especially as the project grows. The list of commands can  quickly become overwhelming and repetitive to execute manually.  Additionally, forgetting to run some of these commands can lead to  production build failures or introduce bugs that could have been easily  avoided by running these commands locally.

Fortunately, there are tools available that can assist you in configuring all the necessary commands to run automatically whenever you need them, relieving you of the need to think about them ever again.

#### **Knock-out repetitiveness with Lefthook!**
[Lefthook](https://github.com/evilmartians/lefthook)
 is an incredibly useful, lightweight, and easy-to-configure tool that automates various aspects of your workflow, including code formatting, test execution, and more!

To begin, you'll need to install Lefthook in your project.





#### **Configure it with ease**
After the installation is complete, you can begin configuring Lefthook by creating a ``lefthook.yml`` file in the project's root directory.



So clean and simple! Now, whenever you commit changes, Lefthook will automatically execute all of these commands. Whenever you commit changes, you should expect to see something similar to this:

![ ](\uploads\blog-Leftook_post_01_6VHv6PDrJMZOEMQSUR0YMM.png)
If Lefthook is not firing, try running the following command:



#### **Built-in features**
 However, this script can be further improved. For example, there is no need to lint the entire project every time you commit changes. Ideally, linting should only be performed on the staged files. 

Moreover, it would be beneficial if the script could also handle fixing any auto-fixable warnings and errors automatically.

Lefthook has you covered with built-in lists of files that can be used for that exact purpose for example ``{staged_files}``.

Updated configuration will look like this:



- ``staged_fixed: true`` makes sure that any file that was changed by ESLint auto-fixing will be re-added to staged files.

- ``glob: “/*.{ts,tsx,js,jsx}”`` makes sure that ESLint is run only against javascript / typescript files within all the staged files.

#### **Running concurrently**
Running each command individually can be time-consuming, particularly when there are numerous commands involved. To expedite the process, Lefthook can execute all the commands in parallel by adding a single line to the configuration file, as demonstrated below:



- ``parallel: true`` will run all the commands concurrently, which should make the whole process a little bit faster.

#### **What else can be automated?**
 Another command that can be automated is the installation of packages whenever you merge changes into your working branch. Other developers may have added different packages at any given time, so it can be advantageous to install them automatically before starting your work.

How to achieve this in Lefthook:





Important to note: ``post-merge`` hook will not run if any conflicts were detected!

Whole lefthook.yml file should like like this:





#### **Conclusion**
Lefthook is a very powerful tool that can help with automating repetitive processes, thus improving the overall developer experience by allowing your team to focus on delivering code that will be linted and tested automatically.

It is very easy to configure in new and existing projects, so I highly recommend trying it out on your own!



Bitnoise Kit - 2022 Edition

Magdalena

How do mid and senior React.js developers cooperate at Bitnoise?

Adam

The 8 pillars of quality of a React.js project

Adrian

How Lefthook helps improve development teams’ workflows

Michał

Bitnoise's 13th birthday

Magdalena

GET IN TOUCH