**According to the current statistics, a poor recruitment process makes up to 50% of job candidates decline a job offer, while nearly 31% of hires decide to leave their newly acquired positions within the first six months. Whether those employees were indeed not a great match for the companies they have left or not, a high turnover ratio always means losses for an employer.**

Recruitment, hiring and training procedures take time and money, while a lack of competent specialists generates expenses related to the delays of ongoing and future projects. The problem is especially acute in the IT sector with its high requirements for technical skills. Moreover, the more new people come into a company, the higher the risks of leakage of unique business knowledge. Finally, fast turnover weakens the morale of other staff members and builds a negative reputation on the market.

## We asked a few of our Devopsbay team members what they think about issues with the right recruitment process.

- ## Senior DevOps - Kuba and Łukasz

**From your experience, what mistakes can you see when we are talking about Devops position?**

Conducting a type of question / answer recruitment may not fully determine whether a given person fits the team. Oftentimes, someone may know the answers to all questions, but not quite coping with problem-solving and teamwork. I am a supporter of a rather open discussion, in which you can get more from the candidate in terms of technology and whether he is a skilled person. Skillset can be enlarged, but characters won't chang

**From your perspective, what are the DevOps competencies needed in a startup and what in corporations?**

I don't know if it matters - I have never encountered any differences during such recruitment. You check the technical stack and / or soft skills in terms of what you have in the project rather.

**Can you tell us also - What counts when you are recruiting a DevOps Engineer?**

I always check whether the candidate is interested in the topic and whether he is expanding his knowledge, in most cases, candidates do not understand the mechanisms of action, and only recreate what they saw

- ### Other Javascript/ Generally developers - Ola

**What mistakes can be made when recruiting a developer?**

It seems to me that the biggest and fundamental mistake is to approach recruitment in IT in the same way as to recruitment in other industries. The IT market is very specific. In this market, the candidates are dictating the terms. The first mistake that we can make right from the start is the lack of specific information in the first message to the candidate.

Good specialists received dozens of messages with invitations to contact during the week and the recruiter must make sure that his message stands out and encourages conversation

The next mistake is the lack of good knowledge of the position we are recruiting for.

Sure - you can always say that we are not sure, and we don't want to mislead the candidate and you will return to him with confirmed feedback, but this should be very sporadic and only used in exceptional circumstances. The well-known and well-worn phrases in advertisements such as "due to the dynamic development of the company" will also certainly not help in recruiting candidates.

When finally we manage to “catch” the contact with the candidate, firstly, we should simply approach the candidate in a human way. We shouldn't treat the candidate as an opportunity to achieve the "KPIs" but as a person whom we want to help find the right place that will utilize his competence and experience.

Of course, it is impossible to treat everyone uniquely and individually,but a huge mistake is the use of scripts when a candidate needs to be approached individually and conducting recruitment in a schematic manner.

- ### MLOps - Damian

**MLOps projects required a lot of knowledge and an understanding of the process. Looking from the recruiting site what mistakes do you see?**

There is a problem with MLOps. Some people understand MLOps as deploying a product or doing something in Kubernetes and many more. They are all right in a certain sense.

The biggest problem lies with the decision-maker. They don't quite feel what they actually want to do with MLOps.

They don't know who they want to employ. So they employ someone who has the best skills, but they do not necessarily translate into the task that he is to perform in a given project.

Companies have a problem with determining what to do, how to describe the processes, how to do analyzes and then do not know how to implement it all correctly.
Identifying the needs of MLops - is the greatest challenge. If this is done wrong, the entire recruitment process will be incorrect

**What do you think, are there some most important MLOps competencies needed in startup projects and in corporations?**

There is no difference. In both, you need the transparency of the process and its repeatability,

If you have some models and effects, there comes a time when you verify the profitability and return from implementing MLOps. Business is all about hard data that helps you make a good decision. MLOps works the same for startups and corpo

The basis is the MLops added values. that is, how the model behaves and how long it will be up-to-date. When MLOps meets business, it has to provide it with some predictivity based on data. Again, this works the same for startups and corporations

### Considering poor hiring practices in the IT industry is essential for building a successful strategy, which helps to attract the right people into the company and create the right conditions for them to grow professionally.

We asked a few of our Devopsbay team members what they think about issues with the right recruitment process 

business_job_interview_concept_2571ce4658.webp

Most common mistakes when recruiting software developers/engineers

It’s been quite the time since pip was included to python by default and the tool came a long way since it’s first version. It has all you need to start your basic python project with primitive dependency management. Additionally, you would probably use built-in Python’s venv for your virtual environment management. Now you may be enjoying your basic setup thinking you got everything taken care of, but let me tell you, there are better ways to begin your next Python project. And that’s where Poetry comes into the rescue.

## Classic approach

So, what exactly is this tool and how it can improve your experience developing your next spectacular application? Well, before I answer this question let’s look at some pain points of using venv – pip combination. First thing is that in some big projects you may want to have different dependencies for both development and production environments. Using pip you may settle for splitting your `requirements.txt` into different files all in the same `requirements` directory with each file name corresponding to stage at which the file would be used. Using this approach your folder hierarchy may look like that:

```json
|-- django_project_root
|-- requirements
| |-- common.txt
| |-- dev.txt
| |-- prod.txt
|-- requirements.txt
```

You would have your basic requirements in `common.txt` file and then in `dev.txt` or prod.txt you would first call `common.txt` file followed by specifying the rest of the dependencies needed for each environment.

**dev.txt:**

```json
-r common.txt
dev_req==1.0
...
```

**Prod.txt:**

```json
-r common.txt
prod_req==1.0
...
```

This way, if you’d like to deploy your code to production you would specify `pip install -r requirements/prod.txt` in your dockerfile while running project locally would call `pip install -r requirements/dev.txt`. This approach, while may look straightforward, becomes more complex as number of dependencies in your project grows. Because it is you who needs to make sure that each file is up to date with what your project requires. And as the time goes by, the chances for a mess in those files grows.
Another thing is when you use venv to create your environments. You may have multiple different projects you work on, each using different python version and dependencies. Some people like to keep their venv folder inside project directory (and that’s what pycharm would do by default), but in my opinion, it’s just adding another folder in already possibly beefy project’s directory hierarchy. Not to mention someone may accidentally push their own venv to VCS making a mess in other developer’s environments. It’s usually better to keep all your virtual environments in separate, dedicated space on your machine, but then you’d need something like virtualenvwrapper to easily organize them.

## Using Poetry

Those were just two examples of possible pain-points of your project, but there are of course more ways in which poetry might be of use to you and make your development process at least a bit easier. “Poetry is a tool for dependency management and packaging in Python”, as the docs write in the introduction. The installation is straightforward, you just call:

```bash
|curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python -`
```

in osx/linux or:

```json
(Invoke-WebRequest -Uri https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py -UseBasicParsing).Content | python -
```

on windows.

You can of course install poetry via pip, but that would make Poetry always use Python version for which it has been installed to create virtual environments. So, you will need to install Poetry for each Python version you want to use and switch between them.

After successful installation let’s see how to use this tool. If you are just starting a new project, you can use `poetry new testproject` which will create `testproject` directory with all the content like this:

```json
|-- testproject
|-- pyproject.toml
|-- readme.rst
|-- testproject
| |-- __init__.py
| -- tests
 | -- __init__.py
 | -- test_testproject.py
```

Or if you want to have a `src` folder you can alternatively call `poetry new –src testproject` which would result in the following folder structure:

```json
|-- testproject
|-- pyproject.toml
|-- readme.rst
|-- src
| |-- testproject
| |-- __init__.py
| -- tests
 | -- __init__.py
 | -- test_testproject.py
```

You can also have your project named differently from your root folder by passing `--name` argument like: `poetry new testfolder –name testproject`. What if you already have your project and you want it to use poetry? Then you use `poetry init` in your project’s root directory, which would help you interactively create pyproject.toml and ask you for both main and development dependencies along the way. Poetry uses this file to keep track of your packages for both production and development environments.

Now, when you have your folder structure and pyproject.toml in place it’s time to create the virtual environment. All you need to do is call `poetry install` which would create your environment in default location and install all the dependencies. This default location for the environment is `{cache-dir}/virtualenvs`, where `{cache-dir}` is specific to whatever os you are using:

- Macos: `~/Library/Caches/pypoetry`
- Windows: `C:\Users\<username>\AppData\Local\pypoetry\Cache`
- Unix: `~/.cache/pypoetry`

You can modify this behaviour if you really want your virtual environment to be installed in your project’s directory using `poetry config virtualenvs.in-project true –local`. The --local flag would set this setting for specific project only. If you want it to be default for all your projects, just omit this flag. For all the configuration settings available use `poetry config –list` or see https://python-poetry.org/docs/configuration.

When you run `poetry install` for the first time, `poetry.lock` will be created in your project's directory. This file specifies which version of the packages were installed and locks your environment to those versions. You want both pyproject.toml and poetry.lock to be committed to your VCS, so the next time `poetry install` is called it would use package’s versions specified in poetry.lock. If you want to update versions later, you use `poetry update` command to update them all or `poetry update django requests black` to update specific dependencies. As for adding new dependencies to your project you use `poetry add` followed by the name of the package. This command will also install the package in your environment. With --dev option the package would be added as dev-dependency. What about getting into and out of virtual environment? `poetry shell` will activate it for you, and then you can use `deactivate` to get out of it just like with venv. There is much more you can do with poetry besides basic usage presented here, including built-in support for building and publishing your packages to the remote package repository (like pypi), but you can read it in a documentation on the official website: https://python-poetry.org/docs/

## Poetry in dockerfile

When installing poetry inside docker container you don’t actually need the virtual environment, as those are only useful in local development. So, your command in dockerfile to install Poetry could look like this:

```json
RUN curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | POETRY_HOME=/opt/poetry python && \
 cd /usr/local/bin && \
 ln -s /opt/poetry/bin/poetry && \
 poetry config virtualenvs.create false
```

Then let’s copy pyproject.toml and also poetry.lock:

```json
COPY ./app/pyproject.toml ./app/poetry.lock* /src/
```

After that we install all our dependencies and we can set additional argument if we want to run our app in development mode for tests:

```json
ARG INSTALL_DEV=false
RUN bash -c "if [ $INSTALL_DEV == 'true' ] ; then poetry install --no-root ; else poetry install --no-root --no-dev ; fi"
```

And finally, we can copy the content of our src folder:

```json
COPY ./src /src
```

Remember, that it is good practice to copy and install your dependencies in dockerfile first, and then copy the content of your src directory instead of using `COPY . .`. The second approach would cause the docker to unnecessarily reinstall all our dependencies on every change in code itself even if we didn’t add any new libraries! By splitting it and installing dependencies first, and later copying the code itself we leverage docker’s cached layers, so on changing the app’s code, only the `COPY ./src /src` layer would be actually rebuilt.

## Conclusion

Poetry is the tool that combines the power of both pip and venv, making development process easier to handle. It has all the commands allowing you to manage your dependencies and virtual environments and is highly customisable on top of that. I dare to say, that if you are familiar with all the pip and venv functionality and concepts, then poetry is both easy to learn and straightforward to use. I encourage you to give it a try in your next project.

It’s been quite the time since pip was included to python by default and the tool came a long way since it’s first version. It has all you need to start your basic python project with primitive dependency management. 

professional_team_programmer_working_project_software_development_computer_it_company_124e3cbefa.webp

Managing your Python dependencies with Poetry

As the name suggests, DevOps is a combination of ‘’Development’’ and ‘’Operations’’, and describing it as “technical agile” seems surprisingly accurate. It is a set of practices and procedures that help organizations to create an agile, collaborative environment that brings together software development, IT operations, and quality engineering so they can:

- Shorten development cycles.
- Decrease time to market.
- Implement continuous improvements.
- Ensure that projects align with company goals.
- Deliver high-quality products to satisfy customer expectations and needs.
- Remove team silos within the company

The implementation of DevOps helps companies improve processes, tools, and efficiencies to create a better workplace environment and to continually add value for customers.

#### DevOps: a culture of getting shit done

As engineers, we (sometimes) have a tendency of over-engineering things and that’s what I believe we did with waterfall. While the idea of Big-Design-Up-Front might have been just fine 50 years ago when writing a program took a couple of hours and compiling it took a couple of weeks, it simply doesn’t apply anymore.

DevOps is a methodology that integrates development and IT operations teams to streamline processes and procedures associated with software development, system updates, and the resolution of performance issues. Improving the communication between development and IT teams allows for greater collaborative opportunity, with the intention of reducing the amount of time necessary to deploy software or updates while also minimizing disruptions such as outages or downtime. Merging development and testing with operations and support into one cohesive DevOps team allows for a more comprehensive view of the strengths and vulnerabilities of a system or application.

Greater agility and operational improvement are two of the core objectives of a DevOps philosophy and a digital transformation that incorporates cloud services can facilitate those goals. CloudOps is short for Cloud Operations, and is the process of identifying and defining the appropriate operational procedures to optimize IT services within the cloud environment. It is the culmination of DevOps and traditional IT operations applied to cloud-based architectures.

Successful cloud migrations require a detailed understanding of the current capabilities of cloud resources rather than trying to adapt existing operational approaches to fit into the cloud platform. Consequently, CloudOps requires an organizational-wide change of thinking. Deviating from standard operations can be a challenging adjustment, but the temporary discomfort is worth the benefits, which include:

**Scalability**

Cloud technology allows you to increase or reduce capacity at any time, without investing in additional space or hardware. Capacity planning and asset management will become virtualized.

**Automation**

Cloud resources automate many operations across the SDLC, which leads to self-healing systems and reduces disruptions to applications or users.

**Accessibility**

A lack of onsite servers allows teams to manage servers and operations from almost anywhere.

**Shared resources**

Cloud-computing allows applications that share common services to co-exist without being interconnected.

**Backup management**

Since data isn’t centrally located or physically stored onsite, disaster recovery processes are automatically in place with cloud technology.

**Metered costs**

Cloud resources track usage, making it easier to allocate expenses accordingly.

**Continuous operations**

Cloud-based systems allow for continuous operations since software can be updated and deployed without disruption to service if the proper mechanisms are in place.

#### CloudOps Best Practices

The transition from onsite servers to a public cloud provider requires a significant paradigm shift. Due to the rising popularity of cloud computing, it’s a change many organizations are in the process of adopting. Using CloudOps in conjunction with DevOps offers your operation more speed, scalability, and productivity. Facilitate your team’s progression to CloudOps by implementing the following best practices.

**Enable agility**

It’s essential that your security or governance team is fully onboard with every aspect of cloud computing. If teams fail to work together and make usage more difficult, the end result will be less transparency and a lack of overall cohesiveness. Don’t create more restrictions; instead clearly define and implement necessary guidelines.

**Empower users**

Although cloud resources require governance oversight and appropriate configuration for the sake of security and compliance, DevOps teams are responsible for the day-to-day use of the tools that manage the cloud platform and would ideally have input about resources. Allow users to self-provision their own machines, or to utilize auto-provisioning so that applications request more machines or decrease capacity based on usage.

**Automate security**

Reduce security risks by implementing processes that use automation to test the configuration of cloud resources. Automating security checks and establishing clear compliance policies to be followed by all teams ensures consistency as your cloud footprint grows and evolves. Remediation can also be automated, allowing developers to mitigate risk without workflow disruption.

**Implement redundancy**

One of the objectives of the DevOps philosophy involves continuous operations and zero downtime. Cloud-based systems make continuous operations possible since software can be updated or deployed without disruption to the application or service. Implementing automation and redundancy at both the cloud provider layer and the application layer helps ensure that the application will be available despite updates or software changes.

**Streamline change management**

Reducing the time between idea development and product deployment is one of the primary goals of DevOps, but change management can create its own workflow bottleneck. Encourage synergy between cloud security and change management by putting processes in place that won’t hinder the development process. Automate change request tickets and orchestrate an agile change management system that encourages all teams to work seamlessly.

**Continuous improvement**

A successful CloudOps strategy isn’t a one-size-fits-all approach and can’t be accomplished in a single step. The ultimate goal is to integrate several teams with different focuses and skill sets into one fully integrated operation. Achieving that requires an assessment of existing strengths and weaknesses among team members and communication methods, as well as decisions about leadership, tools, processes, and budget management. Create a plan for not only the initial transitional period, but also for identifying future optimization opportunities.


Here at Devopsbay, we specialize in custom software and product development for all of your needs. Clutch has recognized our company as having highly-skilled developers and technologists 

businessman_shows_infinity_symbol_blue_background_5869066476.webp

CloudOps vs DevOps

Although running a single container is simple, deploying dozens of them in production is more tricky. As you scale up and your application grows, how you orchestrate your containers will become more and more critical for uptime and deployment cycle time.

Containerization is a bit like cloud computing. Move your workloads to the cloud as-is, and all you will get are workloads in the cloud plus a cloud bill. However, move your workloads to the cloud, with the right architecture and tools and you will reap the full benefits of scalability, lower costs, and agility.

The same is true with containers: going a little further than just containerizing everything brings massive benefits. That’s where orchestration with Kubernetes comes in.

Kubernetes is an open-source orchestrator created by Google and now maintained by the Cloud Native Foundation. Kubernetes automates the deployment and scaling of containers across clusters. It will essentially grab containers, and run them on the available compute power, taking care of allocating and replicating containers on hosts, and scaling up and down as needed.

Let’s examine the benefits of doing that.

#### Scalability & availability

One of the benefits you expect from containerization is to achieve scalability and more efficient use of the infrastructure. Kubernetes automates infrastructure management, from adding new compute nodes to the cluster, to autoscaling based on resource utilization metrics, to terminating unused resources. It supports pod affinity, meaning it will optimize where a container should be placed for the best performance.

Besides, Kubernetes was designed with high availability (HA) as a core principle. Enabling HA is just a few changes in parameters away, and then the cluster will self-heal and load-balance depending on the state of the physical infrastructure.

This means that instead of spending time manually managing and configuring servers, you can spend time optimizing your infrastructure to provide better customer experience and automating more and more.

#### Reduce costs

Kubernetes leverages the portability of containers and automated placement on physical or virtual nodes to optimize capacity usage. Autoscaling means you can run at the right capacity at all times, optimizing costs.

#### Automate manual work. Stop firefighting.

When I reflect on technology trends, I try to always keep the big picture in mind. Besides the need for scalability and native support for cloud environments, high-performing teams seek to implement DevOps principles and automate themselves away.

That means there should be a way for developers to deploy in staging or production without taking too much risk, or without waiting for hours for a ticket to be approved by the team managing the infrastructure. Automating orchestration is a prerequisite to get there, and Kubernetes helps a lot. Natively, Kubernetes automates rollouts and rollbacks, without downtime. We will come back to that, but the array of tools around it also makes it simpler to adopt battle-tested pipelines used in other top-performing teams.

#### Accelerate cycles

A side benefit of automation is accelerating cycles. If deployment and rollback are automated, then it becomes less risky to deploy.

Developers are able to ship their containers to the development cluster, then to use canary deployments, meaning testing new versions of the application in parallel with the old version, on a portion of the traffic. Similarly, product managers can test out features on just a portion of the user base. This contributes to creating a culture of shipping frequently, which impacts engineering, but also product management. Shipping faster means learning faster, resulting in faster go to market.

Shipping frequently also means shipping more incremental changes, and that results in shorter and less cumbersome QA cycles. In a traditional, big release cycle, you ship big pieces of code infrequently. That results in lots of complex testing, lots of bugs, and a lot of rework. It slows the team down because developers have to wait for long QA cycles to know what is working and what is not, but also because fixing the many bugs detected by QA takes time. By shipping incremental releases, frequently, QA costs will go down and team velocity will increase.

This does not come with Kubernetes alone, but it is the result of adding the right mindset to the right tooling. Experience and habits play a big role.

#### No more “works on my computer”

Tools such as minikube (a lightweight version of Kubernetes) allow developers to work locally in a setup that replicates production nearly 1 to 1. That means there will be a lot less variability between the development environment and the staging and production environment.

At their best, clusters become “cattle and not pets”, meaning creating an environment to experiment is fast, secure, and reproducible. There is no more production or development server, and “it works on my computer” does not exist.

#### Deal with on-prem & cloud and avoid lock-in

Kubernetes orchestrates resources, regardless of the provider. As such, it is a good way to orchestrate workloads in the cloud and on-premise, and unify the way a company works regardless of past and future infrastructure choices. Adopting Kubernetes can be the first step in moving some workloads to the cloud while keeping a single way to manage them. There are now tools that allow for easy deployment of Kubernetes on bare metal and in the cloud.

Besides, Kubernetes is open-source, standard, widely adopted, widely supported by a broad array of providers, which will avoid lock-in. Containers deployed in a given hosted Kubernetes solution can relatively easily be moved to another.

Like any technical choice though, adopting Kubernetes is a commitment, and it will somewhat lock you into Kubernetes. But Kubernetes is robust and extendible enough (see below) that this choice will be a good one for the foreseeable future.

#### Future proof and battle-tested

Managing infrastructure requires a lot of tooling, from monitoring to storage to observability. Kubernetes’ ecosystem has become one of its main strengths over time. As Tim Hockin, a Principal Software Engineer at Google and a contributor to Kubernetes puts it, “There’s the network ecosystem, the storage ecosystem, and the security ecosystem”. The ecosystem is growing fast and tackling new use cases, which is well illustrated by looking at the CNCF’s landscape.

Choosing Kubernetes means choosing the orchestrator that 78% of teams use in production, according to a recent poll. That means a robust and growing ecosystem of well-supported tools and less technological risk on your team alone. The building blocks are there, it’s up to you to put them together to build the orchestration system that works for you.

#### Conclusion

The hype around Kubernetes is real, but so are the pains it is solving. Although it has become the obvious choice, it is not enough to “just deploy Kubernetes”: you need to get the right tooling and processes around it to unlock the value.

Over the years, DevOpsBay has helped engineering teams adopt, and customize Kubernetes for their needs, but also trained them to change mindset and workflows to unlock all the benefits. Contact us for a free discussion around how to architect kubernetes for you.

Although running a single container is simple, deploying dozens of them in production is more tricky. As you scale up and your application grows, how you orchestrate your containers will become more and more critical for uptime and deployment cycle time. 

sun_shines_wooden_wheel_held_by_man_c749a03415.webp

How Kubernetes can power up your business

For the next days, maybe weeks or even months we won’t be able to work normally. Unfortunately, if something is happening in the economy or now in the world, entrepreneurs are the first to feel it.

We have to stick together in those hard times. The current situation requires us all to work remotely. For the IT industry, this is the daily bread, but for other industries, it may be something new.

At Devopsbay part of our team works remotely all the time, in addition, we work with our clients from the USA and Europe. The following list shows the remote work tools that we use ourselves. Their knowledge will be useful not only now, but also in times after the “plague”

#### Online meetings - Zoom.us

Zoom.us gives you the opportunity to connect online: audio calls, video, or even smooth screen sharing.

This kind of meeting, when we see the emotions of another person, when we look at one screen together, is much more effective than the best phone conversation.
Why Zoom.us and not for example Skype?

The answer consists of several points:
- great connection quality, even with a slow internet connection
- option to invite to the meeting by sending a link
- simple and free mobile application for iOS and Android
- works from your car (Carplay)
- easy organization of meetings for many people
- ability to record the entire meeting

The application is free, although it has some restrictions:
- no limits for two-person meetings
- If you meet in a larger group (3+), the length of the meeting is limited to 40 minutes.

If this does not bother you, then go ahead and use the free version

#### Cooperation and information exchange - Slack

Slack is one of the leaders in the business messenger market. It allows teams to stay in touch.

Slack features:
- sending messages
- making voice and video calls
- sharing screens between devices
- uploading photos, small video files, or PDF files.

Slack’s biggest advantage over the competition is that it enables the user to belong to various workspaces where many channels and other subgroups can be created. Thanks to this, all our conversations will remain transparent, and we will never lose any thread.

When it comes to tools for remote work, especially teamwork, Slack is an absolute must-have.

#### Tasks and work organization - Trello

For the next days, maybe weeks or even months we won’t be able to work normally. Unfortunately, if something is happening in the economy or now in the world, entrepreneurs are the first to feel it. 

woman_video_conference_call_her_home_office_during_coronavirus_pandemic_dae45079c3.webp

Remote work during times of crisis - effective tools to work from home

Here at Devopsbay, we specialize in custom software and product development for all of your needs. Clutch has recognized our company as having highly-skilled developers and technologists. Our profile on Clutch highlights all of the services we offer including mainly custom software development, but also web development and IT strategy consulting. We also cater to all business sizes from small all the way up to enterprise businesses.

Clutch is a ratings and review firm which does all of the work of comparing companies for you. Based in Washington D.C., Clutch collects reviews of different agencies and service providers and publishes them on their website. This information is conveniently organized on company profile pages as well as on cumulative matrices. Our profile includes reviews from clients, including a quote from the CEO of Leanfra praising our practices in programming, deployment, and CI.

We have also been featured on Clutch’s sister sites, The Manifest and Visual Objects. The Manifest is a blog style review site in which we are featured as one of the best technology firms in Poland.

Clutch’s other sister site, Visual Objects, recognizes the visual portfolio accomplishments of companies. Poland B2B research companies have been featured here and we are excited to join them soon.

>Quote
We hope that this award will help us reach new clients abroad - Michał Kułaczkowski, CEO

We are proud of the work we have completed thus far and we have high hopes for our work in the future. If you would like to look into our company more, send us a note and we’ll be in touch!

MLOps

DevOps

Kubernetes

App development

Infrastructure

Cloud

Blog

Latest

Most common mistakes when recruiting software developers/engineers

All posts

Managing your Python dependencies with Poetry

CloudOps vs DevOps

How Kubernetes can power up your business

Remote work during times of crisis - effective tools to work from home

Devopsbay Recognized as a Top Developer in Poland