Jenkins has been a great tool for maintaining build version and scheduling timely jobs

Jenkins plays a important role in product development and deployment lifecycle, where a developer can build his code and give the build version to QA for testing, ones the build is tested it can be signed off and deployed to prod, Not one but many Different Applications can be created and can be built and maintain the build versions of each applications, Ad-Hoc scripts can be managed and can be triggered when required or schedule it in a timely manor, the jobs can be parameterised or non-parameterised, and can even set default parameter value, The scheduling of jobs are done using cron string, Usually we use linux shell scripts for job build configurations, it can also be done by many different ways. We can configure different executor machines for different jobs to distribute the load, Supports parallel processing of different jobs at the same time, User permissions are manageable (read, write, build etc.. ), It has lot's of native and third party plugins, for achieving different use-cases, and lot of community support, The features are well-documented inline, it has a great version control of the job configuration

Scheduling becomes little complicated if the job has to run in un uniform interval of time, for which we had to set up two jobs with the same build configuration and different cron scheduler, sometimes the application dropdown values disappears when used with different executors , Not a fully cloud-based solution, infrastructure should be managed internally, maintains limited build history,

As automation of script files and file execution, the feel of operation in the system is easy to understand. I started from a place I had never used, but it felt that way. In a nutshell, it is an image of the Linux Cron and Windows task scheduler. It is easy to manage problems that have been resolved, specific effects and CI/CD processing details. When the agent load increases, there is no need to respond manually; automatic escalation will distribute the load. The file (Jenkinsfile) describing the functions, points and CI/CD processing that contributed to the problem can also be managed in the Git repository as a set with the source code, so it is easy to check the processing details and modify the Jenkinsfile.

The amount of information in the search results is significant, and it is easy to operate because it is free (easy to stop in case of emergency). A Docker agent and JenkinsX are also available, so they are compatible with the latest technology. Because it can be used not only on-premises but also with Kubernetes, it is helpful because the learned technology can be used for a long time, even if the stage changes.

Since the configuration screen is displayed in a tabbed format, there are times when you cannot see what you want to edit unless you show it at the bottom of the browser screen.

- It has huge customisation options while creating a new CI/CD pipeline- It greatly reduces the developer effort by automating a lot of stuff- Great for running regular cron jobs

- The UI can be made much better - The erorr reporting in case of pipeline failures can be much better. One of the competitor which wins over Jenkins here is CircleCI

I would strongly recommand to consider Jenkins for your build machines. It's free, powerful and offers a lot of options that payed solution might not even propose.

Jenkins is fully open source, making it easy to install on almost any system. Jenkins comes with many different plugins that allows you to use it with your favorite Engine, versioning solution, etc... Jenkins offers many different ways of creating builds scenario, easy to understand steps, and strong scripting

It's not always easy to find support, and you might need to rely on your web searching skills in order to find some help. Updates can sometimes break plugins so you need to be careful with those. Luckly enough, there are ways to revert updates if necessary. It's not for Everyone, since setting up a server could take time and a lot of trial and errors.