Fortra's JAMS Reviews

Our primary use case is for file automation: detecting the presence of files, moving files from one system to another, doing FTP uploads, FTP downloads, and a large number of custom execution methods. Custom execution methods are a way to create your own code that extends the JAMS toolset.

For example, in one of our systems, it has a tool that needs to be run in order to import a file into that system, which is very proprietary. However, those file import definitions are dynamic inside of the system; you could have 100 different file formats. We created a custom file import/export method for our system. The JAMS job calls the other system's API. The JAMS job definition tells it the path of the file to load and what parameters to use. It then reads and displays the remote system's API return results. Custom execution methods are the meat and potatoes of what we use JAMS for.

We have a single production JAMS server that serves as the primary JAMS node where most of our work is done. We have an agent server where the primary node issues some job commands to run on that agent. Then, we have a test JAMS server which we use when we are testing execution methods and other things. We have plans to stand up a failover server, but have not done so. The back-end database for our JAMS production system is Microsoft SQL Standard Edition and all our servers are on Windows.

Automation is subject to a volatile environment. That's reality. You have a client that provides you a file with the wrong naming convention or in the wrong format, or they are supposed to give you a file at 8:00 AM every morning, then one day they simply don't give you that file. Those are the sort of nuisances that create headaches for your production staff as they are trying to work through and detect them. Sometimes, they will fly under the radar, especially if you have a less sophisticated job scheduler running batch jobs, like Windows Task Scheduler. They run at a certain time and are expected to just work. However, maybe two days later, someone finds out that the file, which we normally get every Monday, was not presented to us. Those are the tricky little devils that will get you.

What we do when we develop a JAMS file workflow is we have certain checkpoints that we put into it. If we have a job that wants to run it at a certain time and expects a certain file to exist, we will have the job specifically check for that. If the file doesn't exist, it will create a very specific, actionable alert. We design that to go out to our file processing operators who can respond accordingly by contacting the client. When we are doing an export, if we want to run a file out of our systems, the job that runs the export could detect there were no records that day. It might report that back, then we can act on it. Or, perhaps after the export job run, you could have a follow-up job that checks to see that exactly one and only one file is available in that export destination.

You can't necessarily prevent environmental issues from happening. You can't expect every client to always do what they are supposed to do and give you what they are supposed to give you every day. However, when they don't, at least you can know about it as soon as possible and take action on it rather than finding out about it by accident sometime down the road.

It has drastically improved our capabilities to scale our automation. Before JAMS, there were a lot of manual processes. We had a couple of operators who spent all day doing that. A lot of the time, with human intervention and manual processes, it is as good as the person following a procedure. Human error is a big problem.

Shortly after we adopted JAMS, our file volume started ramping up. The number of files, reports, and other processes that we have had to automate has grown exponentially. We have been able to keep up with that load. JAMS has been able to scale up our organization's scheduling and automation without adding staff. The people who previously did these manual processes are now trained on monitoring the automation and scheduling of those processes. They only step in and respond to issues, rather than running manual procedures all day.

There are many platforms that an organization might use. We have Microsoft SQL server, Artiva, QlikView, and Qlik Sense. All those different platforms have built-in schedulers: SQL scheduler, QlikView scheduler, Artiva scheduler, and Windows scheduler. Without an enterprise scheduler, all those independent schedulers can only be coordinated by time of day. If you want to export a file at 8:00 AM, then set up a scheduled job that runs at 8:30 that loads that file into your BI tool, in theory that should work. However, that sort of time-based, unintelligent scheduling and coordination between systems falls apart when anything goes wrong. Let's say your 8:00 job should be done in five minutes and you have your 8:30 running on your BI scheduler. If that 8:00 job runs long, doesn't produce a file, or if it throws an error, then your BI scheduler doesn't know and just does what it always does. It runs its 8:30 job because there is no coordination. Now, users are wondering why they have a BI report with yesterday's data in it. With JAMS we have chain jobs together in a sequence. The first job throws an error so the second job never runs because there was a problem. An operator can resolve it and resume the sequence.

We have tried our best to consolidate our scheduling and not to use the Microsoft SQL job scheduler, BI tools, and built-in schedulers, but rather to use JAMS and create custom execution methods to schedule everything in one place.

The extensibility feature, i.e., the custom execution method ability, is the most valuable feature. We can write a C# interface using the JAMS libraries. We copy the DLLs for the client interface over to our remote desktop and JAMS servers. Then, any of our JAMS users can open up a job definition and see the control developed by our developers. When the job command is issued, it executes our developers' code.

I am happy with the exception handling, for the most part. When an exception occurs on one job inside of a series of jobs, it can make that series of jobs stop running, sending an email to someone to let them respond. There is also a monitor view where you can see everything that is currently running and any of the jobs that are currently in an error state. You can find them and try to rerun the job, or cancel it if the job doesn't actually need to be run.

JAMS will attach the console logs from anything that has an error on the email that goes to the operators. Also, inside of the job monitor, you can go to the logs and dig down into the details to see what went wrong.

It has the ability to use PowerShell to schedule jobs, enable, or disable triggers. The fact that they have JAMS PowerShell cmdlets is useful. This is not central to our use of JAMS, but I appreciate it. While they have extended PowerShell and created cmdlets, I tend to use that when I have to do things like kill all the jobs currently in the schedule, if something catastrophic has occurred. I use them on my test server more than production. On my test server, if I am running a bunch of tests and jobs, but I just want to wipe out the whole scheduler, then I can use a PowerShell command to do that.

From time to time, a job is executed and gets stuck in a loop. It gets hung. Maybe the remote system freezes up. Something abnormal happens. It is pretty easy to deal with those. You can see them inside the JAMS monitor because JAMS will automatically calculate the average time that it takes for a given job to execute as long as it has had a few successful runs. The JAMS Scheduler can predict what should take five minutes to run. If it is running for 30 minutes, there is a percentage that shows inside the scheduler that the job is now at 600% of the normal run time. So, you will see this big number, 600% and climbing inside the monitor. You can research that. You can go find the hung process on the source system and respond accordingly. You can set up jobs such that they send alerts or have runaway job limitations. I personally don't tend to use the runaway feature. Our operators notice and respond accordingly to long-running jobs.

The biggest area with room for improvement is the area that my organization benefits the most from using JAMS, and that is in custom execution methods. I happen to have a very good C# developer. Ever since we got JAMS, he has spent a lot of time talking to JAMS developers, researching the JAMS libraries, and creating custom execution methods. He's gotten very good at it. He is now able to create them and maintain them very easily, but that was hard-won knowledge. If I ever lose this developer, I would be hard-pressed to find anyone who could create JAMS custom execution methods as well as he can since there really isn't all that much help, such as documentation or information, available on how to create custom execution methods. 

I really think that they could benefit greatly by being much more transparent about C# development, maybe by making a JAMS cookbook or a developer portal where they could throw ideas at each other.

One of my complaints with the marketing around JAMS is that it says things like, "It integrates with Teams". They talk about integrating with a lot of things, but marketing doesn't tell you that they are talking about JAMS running PowerShell jobs. Since PowerShell can automate things like SharePoint and Teams, that is how marketing gets away with saying it has so many integrations. JAMS doesn't have as many built-in integrations as they advertise. I think they should build more of them, and improve on the ones they have built.

We purchased JAMS five years ago. I have been using it the whole time. I was involved in shopping for potential enterprise job scheduler solutions and selecting JAMS.

I would be hard-pressed to think of any occurrence that we have had over the last five years where JAMS has crashed, had any sort of catastrophic failures, or instability. It is a pretty rock-solid system. I am happy with it.

Scalability is great. It has the ability to add agents. We are a Windows shop, and at some point, I am sure we will expand and add more Windows agents. If we were running other platforms, IBM or Unix, then there are agents for that. A company a mix of systems would do well with JAMS because of that flexibility. The ability to have multiple servers and failover servers is a great benefit. Because we are a fairly small power user, we haven't had to really take advantage of that scalability very much, but we are glad to know that it is there.

It is used extensively across the organization in all our business intelligence reporting data refreshes, data warehouse SSIS packages, file importing and exporting, and file movement. We use it for sending automated ticket creation emails to our ticketing system.

The place where I have targeted for us to extend the solution's usage is in the Artiva systems, where not all jobs are scheduled inside of JAMS. There are still some legacy jobs that are scheduled inside of the Artiva's internal job scheduler. I plan on moving jobs into JAMS and making them JAMS jobs.

When I find room for improvement, I log a ticket with JAMS. So, I have logged plenty of tickets.

I would rate support as an eight out of 10, mainly for lack of documentation and support for the custom execution method development.

Positive

It has eliminated monitoring tools like the job schedulers, e.g., the SQL Server scheduler and Qlik Scheduler. You need to have special skills to go and investigate a job that might be running on those schedulers. We didn't have an enterprise scheduler before JAMS. So, I can't say that it eliminated a different enterprise scheduler, but it does prevent us from having train our operators on all the various systems' schedulers. That is one of the benefits of consolidating your scheduling down to a single enterprise job scheduler; you only have to train on one tool. Once a person knows how to look at the job run history, job logs, and job definitions inside of JAMS, they don't need to know how to do that on SQL Server. They don't need to know how to research a Windows scheduled task running a batch job and know where that batch job logs its results. All of that goes away because you can just look at that in one place.

My experience at a former employer was with Tivoli and Tidal job schedulers. Tivoli and Tidal were larger, more complex, less intuitive, and less user-friendly. We also didn't have the ability to do the C# custom execution methods that we do in JAMS. Also, the price was in a completely different ballpark. Tivoli and Tidal were much more expensive.

It was pretty straightforward. When we started with JAMS, we didn't even have SQL Server. It natively installs SQL Express for you, so you don't need to buy an SQL Server if you don't want to. You don't need to buy agents if you don't want to. You can have all the jobs running locally on the JAMS server. That is what we did for a while before we got the separate agent license. The amount of time to learn how to use the tool was not very challenging. It was pretty easy to learn.

The biggest challenge was when we saw and heard what we could do with custom execution methods. We knew we wanted to do it, but it took a long time for our developer to figure out exactly how to do it right.

The JAMS developer and I are the administrators of the system. We do the upgrades, the custom execution method development, create a lot of the job definitions, and help train people. 

There are two people that I would classify as operators. They monitor jobs. They respond to errors. They rerun failed jobs and move files. Also, if the client gave us a file named incorrectly, it would be their job to rename it, fix it, and tell the client that they did something wrong, then rerun the failed job.

There are about four other power users who create job definitions.

There are a large number of people in the company who might receive an email when a report is finished or be notified if there is a problem with a job that was created for their benefit. However, I wouldn't consider those people as users so much as they are people who benefit from the product. There might be 30 of them.

We have easily seen ROI. This is based on the fact that the number of jobs that we are running, the number of processes we have automated, and the number of new clients and processes that we've added since taking on JAMS without having to add staff has paid for itself in dividends.

Take advantage of its scalability. You can start small. The initial cost is very reasonable. Once you have started picking up the tool and adopting it, then you can scale up from there and buy more agents.

There are annual licensing and maintenance costs. If you add agents or servers, every one you add has an additional annual cost. Then there is the basic cost of any software, which is the server hardware and operating system.

Yes, I evaluated Tivoli, Tidal, and several other enterprise job schedulers. It has been five years so it's hard to remember specifically which others I looked at.

I have three examples of working very closely with enterprise job schedulers. If a company doesn't have an enterprise job scheduler, then JAMS is an easy choice. Really adopting the idea of using an enterprise job scheduler into your company culture is important. You need to move jobs out of all your other job schedulers and centralize them in JAMS.

Don't just use it to schedule jobs on one system. Don't just use it as a Windows Task Scheduler replacement. Don't just use it for batch files. Anywhere that you see a scheduler, you can replace that scheduler with JAMS. Get a good C# developer and start making your own custom execution methods.

Contact JAMS support and get your developers talking to their developers. That will help you get up to speed a lot faster. 

For anyone coming off of another job scheduler, like Tivoli or Tidal, I would tell them that they have made a good choice. This solution is just as powerful and much more cost-effective.

Lean into it. Really use it. Don't just use it for this and that. Don't have your other systems and job schedulers doing their own things like exporting files and then relying on JAMS a file trigger to detect the presence of that file. Have the JAMS scheduler kick off the job that creates the file. Don't do it half-heartedly.

I would rate it as 10 out of 10. Anytime that I am geeking out with other IT guys about their systems and processes, I always end up talking about JAMS.

We have it deployed in our cloud Azure VM environment. So, we have it physically installed on our servers, but it is a cloud deployment.

There are a number of different checks that it does. The first thing that it will do is try to connect to the agents. For example, if an agent machine isn't there and isn't available, the way we have everything set up is that the first job will fail. However, if you have a series of jobs with dependency, succession, then you can set it up so it will prevent the other jobs from running. This way, it is not running things out of order or running things without a job where all the other jobs are dependent upon the first job running successfully. There are a number of different ways that you can set that up within JAMS. We definitely use some of the more simplistic ones since that is what works. 

We don't need enormously complex workflows in the system, and the main functionality within JAMS is really what works for us. We have found that trying to keep it simple, not making things overly complex, within our job scheduling and configuration has worked best for us. If it isn't broken, don't fix it.

It makes everything that we want to do so much easier. We have had a number of instances in the past where we have had developers who have been working on a project, and even though we have had JAMS for all these years, they will create some SQL Server Agent job, or something like that, to run a task. When it is in code review and development is complete, the question always comes around, "Can JAMS do this?" The answer has always been, "Yes." Pretty much anything we have ever developed could be run by JAMS. 

Our operations team who manages JAMS picks the project up, puts the jobs in, and starts running them. Whether it is the developer or some other resources somewhere else in the company, they want to be kept in the loop on the processing of those jobs. We can use the built-in JAMS alerting to keep them up to date. They can be alerted only when there is an error. Or, they can get an alert anytime the job runs so they know whether it was successful or failed. Over the years, there has been a greater adoption of people coming to us, saying, "Hey, can I run this in JAMS?" Instead of them going off and creating it on their own.

Its Interactive Agents are critically important for running jobs on all our various servers. If we didn't have that, we would have to do something individually on each of those different servers, trying to time everything out. It would be nearly impossible.

The most valuable feature is the basic core of the software itself. That is just the level at which you can set scheduling and dependencies between jobs, how everything can be set and scheduled based off of one another, and the ability to run jobs across 25 to 30 different virtual machines. It gives the ability to be able to run jobs on all those servers as well as have them all be visible. In the schedule from one centralized JAMS client location, we can bring up the client interface and see everything that runs across our entire infrastructure, which is really invaluable. We can instantly access all the log files for anything that happens, e.g., if we get any job errors. That is definitely what is most valuable to us. 

There are some different batch queue features, e.g., we can quickly change the servers where jobs are running. When we made a full move to Azure to be fully cloud based, we had to change all our jobs and the servers that they were going to be running on. The way it had been originally set up was that we used batch queues, where each job would run on a particular server and it would be assigned to the queue, which had the agent definition in it. That told it what server to run on, which was very easy. We didn't have to go through and change thousands of jobs. We only had to go through and change about 20 to 25 different queues, then just point them at different servers. Therefore, it was a very quick and easy change. 

We have used some of the built-in PowerShell FTP capabilities within JAMS as well as some of the other PowerShell capabilities. We also use the triggers a little bit, when we are watching for files to appear in a particular directory, etc.

The exception alerting process is reliable; it works. We don't do anything really fancy with it, and it is mostly based on the actual jobs themselves. For example, if an SQL job, some Windows executable, or an SSIS package that we're running returns an error exit code, JAMS certainly handles that and lets us know. It then does, with the rest of the job surrounding it, what we have configured it to do. From that perspective, it is great. 

We have some specific instances where if jobs run too quickly or take too long to run, we use the exception alerting process on probably a few dozen different jobs that we have that are really important. The few times that it happened. It has saved us a lot of headaches because it is able to report those exceptions to us. 

We use a fairly decent amount of the log file exceptions, where you can go in and parse the JAMS job log file for specific entries as it goes through. Then, it can actually error the job out for a job that otherwise might not end in an error. In our case, we wanted to be alerted and have it halt a process if some specific text string shows up in the job log. We have that set up on a number of different jobs, which saves us from a lot of headaches.

It has worked out pretty well for helping us handle complex scheduling requirements. We use it in one specific instance where our customers interact with our web-based platform. It has a section where our customers can go in and run one-off versions of their specific processes. So, they will go in and upload a new file, then they want to basically process that file into the system. What they can do is go to the page, upload their file, and then there is a button there that allows them to process it. That button actually links directly into our JAMS server using the JAMS APIs. That will kick off the jobs within JAMS directly. We have it set up so it only allows it to run it during certain times a day. It can check and monitor to see if an instance of a job is already running for that client. If it is, it returns back and tells them that they need to wait for the current one to finish. It returns the actual history from JAMS so they can see all the previous instances of their jobs that have run. This is a really nice feature that our customers really appreciate. It also saves us a lot of time. What would happen in the first couple years before we implemented this, our customers would upload their file, but then they would send in a support ticket for us to run their processes during the day and all our customer processing happens mostly overnight. Therefore, they would want this intraday update of the process. As soon as we implemented this for all of our clients, those support tickets just disappeared. It made a big difference in our ability to support customers.

I would like the ability to have the JAMS client, where we monitor everything, be fully web-based and secured so only certain people can access it. It should be set up and look similar to the actual JAMS client that we use as a desktop application on the server. A fully web-based JAMS would be nice for traveling or when you are not able to directly access the actual server with the client when we want to log in.

All my machines at work are Macs. JAMS client is a Windows-based thing. It is all built on .NET, which makes perfect sense. However, that means in order for me to access it, I need to connect to a VPN, then log onto one of our Azure VMs in order to access the JAMS client. This is fine, but if for some reason I am unable to do so, it would be nice to be able to have a web-based JAMS client that has all the exact same functionality in it. There are probably a whole bunch of disadvantages that you would get with that as well, but that is definitely something that would make life easier in a few cases. 

We have been a JAMS user since late 2013.

It has been incredibly stable over the last nine years. 

The only issues were few and far between. They baked more down to Windows than JAMS, but that is just how JAMS interacts with Windows, and you will get an instance where a JAMS agent will stop responding. I have probably had that 10 to 15 times total over a nine-year period. It is really more about the Windows VM needing to be restarted. It was something in the Windows network that was out of sync, so it wasn't JAMS causing the issue.

We had no downtime at all for the complete movement of an entire environment, which was great.

The scalability is fantastic. We have never had any issues. We went from a couple hundred jobs to running 6,000 to 7,000 jobs per day now without issues whatsoever. It is extremely easy to use. I feel like if we had the manpower to put all the jobs in and stay on top of them, we could run 60,000 jobs a day through it without any issue. The scalability is more about the server environment that you are putting JAMS on rather than JAMS itself.

Right now, we have two people whose main responsibilities are managing JAMS. That is for new jobs, job updates, looking at job errors, monitoring, etc. Then, we have two to three other people who work in some siloed areas, so they manage their own jobs, i.e., creating their own jobs when they go in. They are still monitored by the main team of two, but there are a few other people who manage it. Within our company, we have about 115 employees. We have about four to five people who regularly interact with JAMS, with two of those being on a daily basis.

I haven't had to use the technical support that much, which I think is a testament to the product itself. However, anytime we have had questions, such as, "Hey, can we do this with our license?" or, "What is the recommended upgrade path if we want to do it this particular way?" They have always been very quick and helpful, emailing back right away, having a phone call, or a video screen share call with us. They give us lots of options. Over the years, we have probably used it less than a dozen times, but every time has been a really good experience. I would rate them as 10 out of 10.

Positive

It didn't really replace anything.

When I first started with Powwr, everything was being run manually, being done through Windows Task Scheduler jobs, or SQL agent jobs. It quickly became apparent that this would not be scalable. It didn't really give us what we needed, as far as visibility into jobs.

I previously worked for another company who owned and developed JAMS, so I knew of it. I reached out to them, and said "Hey, we really could use the solution here." Then, we signed up, got our licenses, and were underway. At that point, we were running about a couple hundred jobs per day. Now, nine years or so later, we are running somewhere between 6,000 to 7,000 jobs per day through JAMS. That is across multiple different servers and platforms. This allows us to keep everything in a single centralized management area where we can have different jobs running based off of ones running on other servers, platforms, and types. It has been really helpful.

For the initial deployment back in 2013, when we first started, we had one main JAMS client server. At that point, we probably only had four or five other agent servers where we were running jobs. That deployment of the software took a matter of an hour or two. It was very quick and easy. Then, we spent the next month or so getting it set up to create all our jobs within it, really figuring out exactly how we wanted to run everything and trying to make it as efficient as possible. Also, we want to be able to make it so we could do the changes, e.g., if we were moving server environments or changing agent servers. We wanted to make it easy to do that.

We did take a little bit of time with planning and setup, but the actual deployment of the software was very quick. Even over the years, when we added a new server to run jobs on, it was really simple. When we do our server deployments, we make sure that the correct firewall ports and everything are open for JAMS. This is part of our standard VM deployment process. We then just use the automatic JAMS agent deployment feature. Therefore, we add an agent and it automatically deploys. About 30 seconds later, it was done.

We deploy the agents to all the remote servers that we have within our infrastructure. Therefore, once the deployment goes out, we are able to run any of our jobs. The biggest advantage that we have gained from this is being able to tie together jobs from our multiple different servers, allowing them to essentially interact with each other through the JAMS agents. For example, we have a process that has a dozen jobs in it and the first two jobs run on one server, then the next six jobs run on another server, and the last four jobs run on a third server. This makes up a larger process that completes some goals for us.

We can take the jobs that we run and write tables. The next job can pick up data from that, even though it is running on a completely separate server. They are all tied together from dependencies, so it makes sure that the right ones run in the right order, even though they are running on different servers. They don't even need to be in our environment. 

We have jobs that we can run outside of our main Azure environment and can run on ones that are halfway around the world, as our company has a US portion and a UK portion. Therefore, we can run job processes where some of the jobs run on servers in the US and some run on servers over in the UK. As far as JAMS is concerned, it is just running the jobs. However, it is a big plus for us because we can keep everything linked together.

Back in 2013, I was the only user of JAMS. We had maybe 10 people in our company at the time, as we were just starting out. Just implementing JAMS on a smaller scale saved me probably five to six hours per day of work. That was massively significant. I was able to sleep at night. Getting JAMS in place was a game changer for us back then. As we have grown from 10 employees to 115 employees over the last nine years, JAMS has grown with us in how we use it and what we use it for.

The pricing is very fair. We have seen very minimal to no price increases over the years. We are not banging down the door of support all the time either. I would imagine if we were a company that submitted a dozen support tickets a week for the last nine years, then it might be a little different because we would be eating up everybody's time. However, for what we get out of it, the pricing is extremely fair. Back when we were originally looking and brought in JAMS, we were looking at a couple of the other competitive products that were in this space, but the pricing from JAMS was far and away better than what the other competitors could offer for the same functionality.

From my perspective, we went straight for JAMS. However, from the company's perspective at that time, they wanted to look into a couple of other competitive products. So, we did do a little bit of that. 

We chose JAMS because it could be very easily integrated into our existing environment. We were completely Windows-based. We were doing a lot of .NET development. It just fit very well. Though I am unsure, it may still be the only .NET-based scheduler out there. To have this capability was really a big plus. 

Some of the other competitive products had a much steeper learning curve. We were able to take some of our employees that had never seen it before, and within a matter of minutes with some quick training, they could get in there, create new jobs, and get things running.

For a while, we had a secondary environment set up where we would run various test jobs. Or, if we were testing out software updates, like JAMS software updates, we would run that environment as well.

I would rate it as 10 out of 10. I would definitely not hesitate to recommend it and have recommended it. 

Most of our use cases are for automating our SQL jobs to run and send an email.

It used to be really hard for us to set up SQL jobs to email, once they were done. Or, if there was a problem, we couldn't get it to do anything smart and intuitive because that's not the way SQL works. Once JAMS came along, we could set our SQL jobs to run at 1 PM every day. When a job runs, if it can't get its data or it takes too long — or whatever criteria we set up for it — it will email us and let us know that the job needs attention.

That really has helped. When I first started here 15 years ago, I ended up having to babysit SQL jobs all day long and watching for code that wasn't written correctly, or for a lock on something that stopped the job, or somebody didn't put timeouts on it. Once JAMS came along, we set up one set of criteria for quite a few jobs, and for every job we could say, "Here's your database, and run it with these criteria." That freed up our developers' time and my time, and we had a trackable source that would tell us what was wrong. It literally changed all of our lives.

I no longer have to wait for someone to give me all the information about a job that failed, wait for somebody to respond, or question somebody about what they're asking me to fix. It's all right there. The dashboard for JAMS is very intuitive and informative.

It's helped save time—in the extreme—when troubleshooting. Our jobs don't necessarily stall anymore because we've fixed everything that ever stalled. We now know how much of a timeout to put on certain data sources or certain procedures, but we would not have known that as easily without JAMS.

When we first began using JAMS, it freed up about 50 percent of my time, or 20 hours a week. And it saved each developer about 10 hours a week, and maybe more. There have also been some advances made in SQL that have helped. But because we've been using JAMS for so long, the savings are really immeasurable. We've relied on it for so long, and we'll continue to rely on it in the future.

When a job doesn't work, all I have to do is open JAMS and open the job and, 99 percent of the time, it tells me what I need to do, or what happened, or I know where to look. Before, if a job failed and just kept failing, we had no idea where to even start looking. We'd have to go to the logs on SQL Server, which meant everybody had to have admin rights to look at the logs. Now, we have just set up JAMS to run with a service account that has the ability to do that, and then everybody can look at their own jobs and fix them. Sometimes, it's just a matter of needing to rerun a job because something was down in the network.

By setting it up with a service account that has access to everything, we don't have to run it under my name or anyone else's name. We can set it up so that everybody has permission and I don't have to worry about granting someone permission. And I don't have to give them access to the email account where the failure or success email might be sent. Everything is done with the agent or the service account. And when a new data source comes online, we just give it to the service account agent, and that sets it up so that everybody has access.

Another way it has helped is that before a client logs in to see their daily reports, and they're not there because something happened to them, we're saved by the fact that JAMS emails tell us that it's happened. We can go in and fix it before the client logs in and finds out that something failed. Or, if something was down, like FTP, we can let the client know in advance so that if they log in, they will know that the data is not available and that we know already and are working on it. JAMS has made us look smarter to our clients.

For example, when you log in to your computer and do a local Google search for shopping, the results that you get can cost our client a lot of money. It is very hard to get the top result without spending a lot of money because what Google says is that your data integrity matters a lot. If your data is stale, or you haven't done a refresh on your inventory, Google will push you down in the results and move somebody else up. That means that stale data is a big concern for our clients. Some of our clients rely on Google for 90 percent of their business. If we have their data messed up, their business is messed up because of us. We have to know that their jobs are failing and why, and be able to tell the client, early on, that this is happening so that they can do some manual uploading until we fix what's wrong.

The scheduler is the most valuable feature. Using that, we can set up all of our data sources to be available. We use multiple different data source providers and they're already in JAMS. All somebody has to do is go into JAMS and say, "I want to use Adverity," or, for whatever client it is, that they want that client's data for these dates and these criteria. They can specify that they want it sent to this database or that FTP, and with only these column names. Whatever we want to do, we can almost write the code to do it in JAMS because we already have so much data in there. It's as if JAMS has made itself into its own picker.

It can also do exceptions, you just have to remember to program them in. As a rule, when you first start out with a job and JAMS, you probably aren't going to tell it what to do with errors until you see a pattern in your errors. And then you can say, "Try three times but wait five minutes each time." You go into the job in the monitor and it says it failed. Then you can change the criteria, such as how long it's holding, or repeat the job every 10 minutes until successful.

The code-driven automation for more complex scheduling requirements frees up time because it's really easy to use. It looks complicated, and when people start using it, it might seem a little bit overwhelming, but after you get all the definitions set up, it is very easy to do. It's almost like a stand-alone software that we can't live without.

JAMS is going to disagree with me about the following, because they think that this is not always a problem. But since COVID, we have had a lot of people working from home who can't always connect to the JAMS server. We use VPN, as most companies do, and we have it set up so that everybody can access the JAMS server. But many times, our people cannot access it.  They'll try to log in to JAMS and will tell me they can't and I don't know why not. Nothing has changed. 

I have to look at their access and what is wrong with their IP. We've discovered some problems over the years that have been the cause, and that's because it's all behind the scenes to us. We have two VPN servers and we figured out that one of the VPN servers didn't have the permissions for it to log in to the JAMS IP address. We fixed that. And sometimes, new people think that they can just log in to the JAMS server, but they haven't been set up with permissions. 

But JAMS could do a better job of telling you what the problem is when you try to log in to the server. The way it works now is that if you can't log in to the server, it brings up a long form that you have to submit. And nobody likes to submit a long form and sit back and wait.

We've been using Fortra's JAMS for at least eight years.

JAMS is scalable but the problem that our company has is that we have about 144 companies under one banner. For example, if we have an airline company under our banner, and another company has an airline under their banner, we can't be connected because that would be a breach of contract.

That means we can't share our JAMS server with another company under our banner. That's a limitation of the JAMS license because you can only use JAMS on one server at a time; one license, one server, that's it.

Given that we're paying all that money, it would be nice if we could have it installed on a couple of servers so that one airline and another airline could both use it but not be on the same system.

JAMS support is very responsive and they know who I am when I call, so I don't have to go through their making sure that I'm an authorized user, et cetera. 

JAMS has versions and they only work with certain other versions. For example, if JAMS 21 is the current version and I'm setting up somebody in it, but they're connecting to our on-prem server, they have to have JAMS 6 instead of JAMS 7. If I put them on the wrong one, they'll never be able to connect. So when I have to re-download an older version of the software if I don't have it saved, JAMS always reaches out to me and says, "Do you just need software or something else?" They take a proactive approach to their support, which I appreciate because sometimes, when they contact me because I have to do a download, I'll say, "Hey, I have a quick question," and I can throw that in without waiting for a couple of days.

They're really the closest thing that we have ever found to being like a coworker who is dedicated to doing nothing other than fixing and scheduling things and checking on all of our data.

Positive

We never had any monitoring tools, other than the fact that we could look at the SQL logs, but that's like reading a foreign language. Rarely does the log ever lead you to an actual solution to a problem, whereas the JAMS logs do. They tell you what happened and to look at this or look at that. Sometimes it will even let you know that a password has expired, for example. At times, it tells you everything you need to know. At other times, it gives you enough that you know where to look and you can see that the login is not working, or the source is down, or for some reason, there's no data there for the day.

Things have probably changed, but back then, if you had SQL 2016 and 2018 and you set up a scheduled job for data in 2016, some of it was bound to fail. With JAMS, we don't have to worry about that because it will automatically tell us what version it is, and even tell us it won't work so we can easily fix it.

The initial setup was very straightforward. I can also export from my on-premises JAMS and import them so that the jobs and all the data criteria do not have to be set up on a new server from scratch. That is very helpful and that's what we did when we put it on the Azure server recently. 

For that project, we initially set aside three days where four of us were going to work on it because it took years to get JAMS exactly how we wanted it and we thought it was going to take a while. But it was very simple. It was up in about two hours.

A lot of people in our organization use JAMS with the service account. But in terms of people who set up new jobs, we have six admin users. There are another ten or so who use just the service account.

When we first got the software, we had something like two half days with JAMS people over a screen share. We've always had a service contract with them and the couple of times we've ever had to reach out to them they were very responsive. When we set this up, on our Azure server. We did not have to reach out to them.

We have absolutely seen return on investment with JAMS. It comes down to the fact that our developers can actually spend time developing instead of troubleshooting and looking at why SQL or the data source isn't working. Or they can simply say, "Hey, I got this email from JAMS, Kammy can you look at it?" Or they can say to my boss, "We have to stop using this data because every day we're having problems getting into it. Can we have a meeting about this?" All of that is JAMS-driven.

In the end, you'll find that it's really worth the price. There is some sticker shock, but it's worth every dime.

Several of us evaluated other options, but JAMS was what we all came back to because it was the only software we found that could do everything that we needed it to do for all the different kinds of data that we get. We deal with over 90 data sources with different kinds of data from different kinds of companies, and JAMS was the only one we found that really could handle them all.

JAMS doesn't centralize the management of jobs for all of our platforms because we have things that aren't built on SQL databases. We can't automate the login to some of the data that we work with because other places don't allow it. We would have to do that interactively with JAMS, so it would almost be pointless to use JAMS for something like that. But JAMS centralizes most of it. If you look at our scheduler compared to how many people used to have to run jobs manually every single day, or had to remember to do something and go back and look and see if it was successful, every single day, the difference that JAMS has made is tremendous. That is why JAMS is worth every bit of its very expensive cost.

My advice would be to understand that if you're spending hours a day or a week trying to figure out why

• SQL or automated data jobs or
• logging in manually and downloading data and moving data around or
• even archiving data (we do a lot of data archiving through JAMS because we can tell it: "if older than X, delete it.")

isn't working, JAMS can handle it all.

For anything that you code manually or have to pull up a script in SQL and look at logs for, JAMS can make it all easier, so that you don't have to do those things every minute of every day. You can spend about 10 minutes a day on them, whereas you might have spent three or four hours before.

It has set times for set jobs that have to run, jobs that previously would have been done by someone manually. JAMS covers that now. But it also helps afterward. If I have to run something on four or five servers at a set time every day, I would have to make it run, check a log file on that server, and flip about between all the servers. Now that I have it in a central location, that is much easier.

For my job, in operations, and for IT, it has definitely helped to centralize the management of jobs on all our platforms and applications. If it didn't do that, we wouldn't use it. When our contract with a competitor was up, we looked at other companies, like VisualCron, that were cheaper, but one of the main sticking points was the fact that they wouldn't have provided a central location for us to monitor across all servers. That was one of the biggest selling points of JAMS.

It enables us to scale quicker, and it has saved countless hours of manpower. I can actually fire-and-forget some of the stuff now. I know that JAMS is going to tell me if some of the basic tasks haven't succeeded. I can do more things with my day. It handles about 1,000 processes for us a day, processes that would require something else, and about half of them that would require a user or person on our side to do something.

It has helped to free up IT staff time in every way. If I had to do all the things that JAMS does for us, I might not get to do anything else. Four to five hours of an eight-hour shift are probably saved by having JAMS do things for me. Everything that JAMS does is what our entire team would do for the day. But because we don't have to do that, we're free to work on other tasks not related to operations, such as customer issues or our ticketing system. If we didn't have JAMS we would put something else in. There would be no way we could do everything without JAMS. Or we would do it, but it would be a nightmare. At least fifty percent of our overall staff's time, of seven people's eight-hour shifts, is saved.

JAMS is also giving us more access to data that was there. It has improved our ability to process and ingest it. We're a financial company and we run on schedules and set times and changes to data are important.

Another factor is that it certainly helps save time when troubleshooting stalled jobs. The fact that it will give you the log as it is written, rather than having to wait for something to finish, is helpful. At least you can see how far along the process or application has gotten and that gives us a place to go when troubleshooting. We have the ability to start and stop something if we need to.

The amount of time it saves us would depend on what has failed. We don't have a lot of failures because we can't afford to have failures. But it could save us about ten minutes on a job in investigating what step it failed at. When a process is running, if we know exactly where it failed, it means we don't have to go into a database or go look at logs to figure out how far along we are. Or if a job had to write 20 pages and we look at the JAMS log and it shows it has only written 10, we know where to go look. Whereas if it just said "stalled", we wouldn't know where it stalled.

Also, we had our own bespoke file-watch system, but the JAMS file-watch is so reliable that we use it for monitoring that sort of thing. It has removed personal monitoring of jobs and having to go in and look for things, but we needed to create JAMS into a separate monitoring system. It has definitely helped.

Some of the valuable features for us are the

• automation
• scheduling of tasks
• file watching
• dependability.

It's basically a super version of Windows Task Scheduler.

Adding Interactive Agents is extremely important to us. Running interactive tasks gives us a central location for multiple processes across multiple servers. If we didn't have JAMS, and we were using just a standard Windows Task Scheduler, we would need some way to log in to multiple servers at the same time, look at jobs and check if one had finished and then kick off another one. You can do all of that by just following one item in JAMS. You can set sequences with a dependency on one thing finishing before something else will start.

It's very good at bridging the gap between structured batch automation and processes happening on desktops. That's really what we do with it. It does its job and it does it very well.

I also like the way it handles exceptions. It can handle its own exceptions, but we can also configure it to handle exceptions from our bespoke applications. If there's a certain return code, we can get bespoke errors. That means it can either give you a JAMS error saying, "Something happened within this job", or it can give you, as the error, what happened within your application. That's very important to us because we hook it up to a different system and what comes out of JAMS goes into a different system separately. It works.

The documentation is not super. There are things that I want to do in JAMS, but I just haven't gotten my head around them yet. For example, I keep saying that workflows would be really handy for us. We can't risk moving our production stuff or testing stuff there. But when I'm testing in the UAT environment, I run out of jobs. They have examples that don't apply to my situation when it comes to running things. The documentation is probably all there, but it's not the easiest to navigate through. It's not as quick and slick as I'd like it to be.

Their support team is a live chat and they are top-notch. I can say I have a job that's failed because of something, and they can probably give me a pointer, really fast, on what's happened, but I wouldn't use them if I'm trying to learn a new functionality or process. I wouldn't ask them to give me a complete step-by-step. That's not their function. They would probably point me to some documentation that would be a massive PDF or some support page, but I just lose the will to live reading them.

I've been using Fortra's JAMS for two or three years.

The stability is fine. I have had no problems with it. It's one of those things that has never gone wrong for me.

It's very scalable. You would only be restricted by the number of jobs that you are licensed for. You can buy a license for, say, 10 jobs and scale to 10 jobs. You could buy a license for 2,000 jobs and scale to that. The costs go up massively, though. The ideal would be to have unlimited jobs; that would be amazing. Technically, JAMS can be as scalable as your infrastructure will allow, but it's probably not as scalable due to what your wallet will allow.

Their technical support is excellent. They're a straight-up 10 out of 10; really good. I've only ever contacted them via email and live chat. Once, when I couldn't get through on the live chat, the guy made a Teams meeting with me, we shared screens, and he went through it, because there was some strange error I was getting. 

Those guys are brilliant. And if you don't get them on live chat, someone picks you up on an email very fast. I can't say enough good things about JAMS for support.

I wouldn't bother them with questions about how I should do something. I would only use them when I have set up something and it's not running as I think it should and I don't know how to make sense of it. But if I've done, say, 80 percent of the work and it's still not working, they will say, "Oh, well, you've missed these four configurations."

Positive

JAMS has made us more productive. We didn't have to hire someone new to do some of the stuff we wanted to do because we could pawn off some of the work on JAMS.

Once you get all the basic server permissions in place, the setup is easy. It pretty much does it itself. You install the main client and a few files. You configured it a bit, and then installing the agents is easy. It's more about the infrastructure you have set up. That is where your main issue will be.

It's on-premises. We deploy a central client on a server, and there are agents that go onto production servers, like an application server, a database server, or a web server. You can set all your jobs from the central location and it will run them on the actual production server. Take, for example, a PowerShell script. You put all of that into the main client and it just runs that wherever you're asking it to. That's what the agents are.

From "blank" to actually getting JAMS working took half an hour. But it depends on how far you're going with it. If I wanted to just get the JAMS client and one agent set up, that would take half an hour. But we have loads of servers and we're constantly adding to it. Per agent, it takes about 10 to 15 minutes.

We didn't migrate to JAMS from something else. You configure all the jobs, but you wouldn't want JAMS to help you with that because they're your jobs. You're telling it what to do. We went from manual tasks. It all depends on the size of your deployment and how much you want JAMS to do, as well as on the complexity of your jobs. Some of your jobs could be one-liners and some of them could be multiple steps and they can go up to massive complexity.

We did it in-house. We knew what we wanted to do with it. Most of our stuff is command or PowerShell, SSIS, and SQL. And if anything goes wrong when trying to set up a job, we talk to their support team, but we're fairly handy with what we are doing.

Installing the actual application took two or three people, and included someone setting up permissions and someone configuring things. But in terms of setting up how our JAMS works compared to a blank JAMS, everybody gets involved.

I'm sure we have had ROI in terms of how productive we are and what our output is, but I wouldn't be able to quantify it.

Definitely check how many single processes you want to run and count them as jobs. That is how you would work out your pricing on JAMS. For example, if you're running a number of commands and you can put them all into one script and run that script, you can count that as one job. That job count is where you're limited, per day. 

You purchase a number of jobs in your license. You can be clever with that by combining things into one job. If you can configure it right, you can get around those limits and save some money.

There are loads of other applications that do similar things, like Octopus Deploy, but they are for installers.

Our shortlist came down to VisualCron, which we tested as well, and JAMS. The reason we went with JAMS was that if I have JAMS open, I'm probably on a page called monitor. That is the list of upcoming jobs that it's about to run or jobs that are executing. After a job has run, it will sit there for about ten minutes and then it will go to a historical page. That monitor page is vital because it shows us what's coming up and how something is executing as it's happening. It gives you a log of updates and you don't have to wait for that until it has finished the job. You can see the log in progress.

The benefit of VisualCron was that it gave us an unlimited number of jobs, but an updated scheduling page like that literally wasn't feasible.

We didn't test the other solutions we looked at mainly because of cost. Our main requirements were cost and the number of processes we could run a day.

If you're looking at JAMS, you probably know what you're looking for. It's a scheduling tool that probably integrates with whatever you're already doing. It takes the manual stuff out and it can connect to just about everything Windows already, including SQL Server, PowerShell, and the command line.

If you have a lot of manual tasks that you run, JAMS can probably run them for you. You'll want something reliable like JAMS.

We started with basic tasks because we were bringing things over from Windows Task Scheduler. We didn't have a whole lot of dependencies at that point. We have gotten much more detailed in our scheduling requirements since. We use what are currently called JAMS Setups, which in the new version are called Sequence Jobs, quite a bit, especially for our enterprise data analytics team. We do some pretty complex scheduling scenarios.

We also use it for holiday calendars that impact our scheduling and for multiple regular scenarios, such as dependencies on a file or another job or another Setup. 

Overall, we use it for basic, normal enterprise-scheduling solutions.

We've been able to automate a lot of processes that were done manually before. We're not a huge company, and we're a fairly new company, so a lot of things were being done before in Task Scheduler or in a homegrown solution called Batch Nucleus. They were also in cron and in SaaS. They were all over the place. Being able to consolidate all of that into this one enterprise scheduling solution allows us to put dependencies on different jobs between different systems. It also allows us to monitor everything from one place and gives us the ability to do some exception handling. We have unlimited licensing with JAMS and we have hundreds of environments that we have agents on and do testing on. Having one location that we can monitor everything from, and handle all the exceptions from, is critical.

We've automated our critical processes, which used to be done manually through an external product and that means we don't have to worry quite so much about manual, human error.

Because we have gone from a lot of manual processes to automated processes with JAMS, we have been able to free up IT staff time. We're not spending 30 minutes doing something manually that JAMS can do in five minutes. It has freed up IT resources, but it has also sped up our processing times. For just the Technical Operations Center team that I manage, it has saved about 20 hours a week.

JAMS has also helped eliminate “data slack” across our applications. All of our enterprise data analytics is done through JAMS, so being able to access things like Teradata, Hadoop, and Snowflake cloud solutions for data integration is important. Our company is based on data. Everything we do is data-driven, so it has been very valuable having one place where we can process all of the data and do batch schedules with chunks of data. It's been a good tool for that. Having current data ready to go when our users need it is extremely critical because we are a FinTech company. We have to be able to pull data instantaneously to make decisions. Otherwise, our customer base is reduced and there are also compliance issues. We have both financial and legal obligations to our partner companies, so that data has to be up-to-date and ready to go when they request it.

I've used a lot of the other scheduling packages in the past. The most valuable feature of JAMS is the ease of being able to update parameters on-the-fly. Also, their monitoring and historical views are pretty robust.

We are also able to go into a job that is inside of a Setup and say, "Turn this one off for a while," by using the Except clause.

Another useful functionality is being able to pass parameters and variables between different jobs, and different steps in a job, or a Setup.

JAMS handles exceptions fairly well but there are some areas where it might improve a little bit. It has to do with being able to automatically handle exceptions, out-of-the-box, rather than having to code them. I'd also like to be able to do different things, based on what the actual exception is. In our current version, there's a placeholder where you should be able to do some things along those lines, but we've never actually been able to get it to work. I've seen in the 7.x versions that that has been fixed.

In terms of automation, there are some scenarios that we're still working on trying to automate and we just haven't been able to find an applicable solution through JAMS for those yet. I'm excited to see, once we get to that point, if we can do those things in the newer version.

I started using JAMS in June of 2016. I was in charge of taking all of our disparate scheduling systems and converting everything into the JAMS scheduling package. I have used it from the ground up.

Right now we're on-prem, but we are going to want to go to the cloud sometime next year.

In the five years that I have worked on JAMS, I have never had it crash.

The fat client on your machine, for the 6.5 version, is not really reliable. It can slow down and it can get hung and you have to restart it. But with JAMS itself, the only issues we've had were when we didn't get the license key updated on time. For the most part, JAMS has been a very steady, reliable tool.

Because we have unlimited licensing, it has been extremely scalable for us. We can put agents on whatever servers and environments that we need to, fairly quickly and easily. We now have that set up as an automated process. So it's extremely scalable, based on the pricing model and how many agents you're allowed.

Technical support is an area in which JAMS has come a long way. When I first started with them, they didn't have any kind of training. The way it worked was that if we had a question, we would call their support team and there might be some back-and-forth trying to figure out how to get what we needed. But they now have JAMS University where you can go to a boot camp and learn more about the product. 

And their support is pretty good and pretty responsive. They get back to you fairly quickly and they usually have a good solution to whatever your issue is. And while they have generally been responsive, there have been several times when getting an answer has taken several weeks, instead of being able to get a really quick answer. I would rate JAMS support at seven out of 10, but I wouldn't give more than an eight for the support for any product that I've worked with. That makes a seven a high mark, for me.

Neutral

We spun off from another company, and that other company used Control-M. When we went our own way, we didn't bring Control-M with us. The scheduling solutions that we were using before were Task Scheduler, a homegrown solution, and SQL Server Agent jobs, things that aren't necessarily true enterprise scheduling solutions.

In our migration to JAMS, we had to refactor some of the code, but that's because of the way that it was coded before. SQL Server Agent and Task Scheduler were pretty easy to migrate because there is actually a conversion routine where you can log in to a machine from JAMS and just say, "Go pull the job and convert it." It would automatically convert it, and we would just have to do some cleanup. That part was easy. But when it came to some of our other stuff, we pretty much had to build it from scratch.

I was the only person working on the migration back then, so it took about a year and a half to get everything over, but a lot of that was because we were having to go find things that were being scheduled on these other boxes. Some 80 percent of it was done within the first four to six months.

JAMS is close to the lower end of the pricing models for enterprise scheduling solutions. They are much cheaper than Control-M, as well as some other products that I've used.

I also don't know of another solution where you can actually get true, unlimited licensing, where you can have as many instances and as many agents as you want. That has been a godsend for us because we have environments that we spin up and take down on-demand. There are times when we have hundreds of environments going at one time. Having that lower-cost model has been really good for us, while still being able to get the functionality that we need from the tool.

Maintenance and additional features are all included in the yearly cost, and that cost is still much cheaper than what you would pay for maintenance for another product.

The one that I had used most recently, and the longest, was BMC Control-M. It is an extremely robust product that has the ability to do some things that our current version of JAMS cannot do. For example, Control-M has the ability to truly diagram out what the flow looks like, from within the tool. My understanding, after having talked to my scheduling analyst, is that that feature is coming up in a future version of JAMS, which is cool.

Control-M also has the ability to do batch impact analysis, and to put a job at the end of a job flow that says that if anything in the job flow breaks, provide an alert. JAMS has the functionality to do that in the current version, but you have to code it. If you want to say, "If this job fails, I want this other job to run to fix it, and then come back and do this other job," you have to code it. But I believe, again, in the newer versions, it's easier to do that type of flow by using Sequence Jobs. That's the biggest area where I felt JAMS really needed to improve, in automatically handling issues, and they've come a long way.

Control-M enables you to send different types of notifications based on the output, which is also a feature that's coming up in the 7.0 version of JAMS.

JAMS has taken quite a few of the recommendations that we gave them and has built them into their newer versions of JAMS. It has been an exciting journey for us to be able to have a lot of input into how the product works.

I'm really excited that we're trying to upgrade to the 7.x version, because it's so much better. But it's a huge change to go from the 6.0 version to the 7.0 version. The tool looks completely different. It works differently, with different ways to do things, so there is a big learning curve. Since our developers build their own jobs in the lower-level environments, it's going to be a big learning curve for our entire company to start using the most current version.

We've defined our complex scheduling scenarios the way that JAMS works in our current version, but in the future version that's going to be much easier. That version has the ability to create multiple schedules on the same job, instead of having multiple jobs with different schedules doing the same thing.

In terms of the upgrade process, we have multiple instances, including development, stage, and production. We've been trying to build a test environment and we have been doing a lot of our tests there. For our actual cut-over and conversion to the newest version, we are being told that we can actually upgrade in-place, instead of having to do a conversion of our database. We're going to take a two- to three-week freeze on any scheduling updates and on adding anything new. Then we'll convert our development instance and train all of our developers on how to use it and what the differences are. We'll let them test. Then we'll upgrade our stage environment and let them test on that. As soon as all of that looks good, we'll do an upgrade of our production system.

We will be working with HelpSystems on the upgrade when we get a little bit closer to it. At this point we're still trying to figure out exactly when we're going to be able to do it. But we have asked them multiple questions and gotten a lot of good feedback from them.

In terms of saving time when troubleshooting stalled jobs, JAMS could do that. But we don't have all of our code set to send the output from a job back to JAMS. So in a lot of instances, we're still having to dig into the system, like Informatica, to get that log back and find out what's wrong. That is something that we, as a company, need to improve. It's not a lack of functionality on the part of JAMS.

We use it to schedule batch jobs. Batch jobs are a combination of SSIS jobs, which is actually our group's main use case. I brought it in mostly to schedule our SSIS batch jobs. Then, there are other groups who are using it for SQL Server stored procedures. We also have another group using it for a few Python scripts and FME, which is a different type of ETL tool. So, we are using JAMS to schedule those four types of jobs as well as a bunch of FTP jobs.

The application developers have been doing a combination of migrating some of their older jobs, like Python scripts and SQL stored procedures, and FME jobs over to JAMS. Any new batch jobs that they are creating default to using JAMS. They mostly do interactive online type applications. However, on occasions where they do need batch processes, they just use JAMS.

The fact that we no longer need to use Excel spreadsheets is huge. Before JAMS, every group was keeping track of their own batch jobs. Nobody really knew what the other jobs were. So, if jobs failed, other groups wouldn't necessarily know. With JAMS, everything is done through a single scheduler. You can choose who to notify. 

The ability to work out dependencies between jobs is the most valuable feature, which is actually the main reason why we went with JAMS. We went from everybody trying to keep track of stuff on Excel spreadsheets to being able to see things graphically, and say, "This job should not continue or start unless another job begins." That is very useful. Plus, we have a bunch of jobs that are using File Watchers. So, the job doesn't start up until a file is put on a shared drive, which is the automation that JAMS provides that the old SQL Server agent did not do at all.

It provides notifications. 

The fact that JAMS provides metrics is actually nice, although this feature is not really used that much. Before it was a lot harder to get metrics, whereas there are now metrics if we want them.

The client needs a complete revamp as it is not the most intuitive of methods of setting up jobs.    We have encountered situations like options disappearing and with no obvious way of getting it back, we have had to open up a Support ticket just to figure out how to get the missing options back

I have been using it for around three years.

We are about two versions behind. Our upgrades are done by our infrastructure team. We decided that to reduce the amount of work for them that we were going to limit upgrades to approximately every six months, because JAMS does frequently update their software. For the most part, it is fairly stable. We have basically worked out with our infrastructure team to not update every time a new version is released. So, it is done around twice a year.

The product is quite stable and we haven't run into any major issues.

Our infrastructure is pretty straightforward. It is just SQL Server jobs. It works fine on all our Windows machines. We might be exploring a Linux machine for scheduling a SQL Database job, but we haven't done that yet. 

The plan is to have all our batch jobs managed by JAMS. For various reasons, mostly related to strange quirks, they weren't able to just migrate every single thing to JAMS, but that is the end goal. We want to have a single scheduling tool that manages all our batch jobs.

We haven't really encountered any scalability issues. Most of our jobs run at night. We have a bunch of daily jobs that run every half an hour. Therefore, it has not been a huge strain on the JAM server.

There are not that many users of JAMS, probably five or six. We have one administrator who is part of our infrastructure team who can configure JAMS etc., but acts in more of an implementer role. He was the one who installed the software. Setting up jobs and things like that is left up to my group. There are two people in my group who have permission to create and submit jobs. Then, we have about three or four inquirers who look at the output of the jobs, but don't have the permissions to submit jobs.

Reach out to their support, because they're support is really good.

I would give HelpSystems IT support a nine out of 10, which is really good. I have been very impressed with their support. The only reason for a nine out of 10 is sometimes it takes at least a day for them to get back to me, which isn't really that big a deal. However, for the most part, if we do it within U.S.A. working hours, then I get a response pretty quickly. Also, after hours, I think I have sometimes gotten their London support.

We have had situations where we would hide things and could never figure out how to actually get things back. We would inadvertently just hide things without even knowing that we hid them, then we literally have to reach out to JAMS support. As far as kudos, JAMS support is excellent. They are very responsive. There have been little things like, "We lost a window. How do we get that back?" The fact that you had to hover over a specific area of the UI, then depending on where you hovered, you could get that particular window pane back. That was the first thing that we ran into, because it was like, "We lost this. How do we get this back?" 

I actually was the one who brought the product in. My group was looking for a scheduling tool. Until I arrived, everybody was just using the built-in scheduler, which was fine, but it was impossible to look at things practically or even determine dependencies. So, everybody was just using spreadsheets, but I hadn't. The place I came from, which was the private sector, had money. They were using a full-fledged scheduling software, Control-M, which was really expensive. When I came to San Francisco Public Works, they didn't have it. Therefore, I started looking around to see what was available. 

Previously, we were using SQL Server Agent. Migrating these has been going well. One of the great advantages of JAMS is it can just convert SQL Server Agent jobs directly, which is not ideal because you are still running SQL Server Agent. This is one reason why we are doing things slowly. We are decomposing the SQL Server Agent jobs into steps and scheduling those, rather than running SQL Server Agent jobs.

The initial setup was pretty straightforward. We just followed the instructions that were on the webpage. So, on the actual JAMS site, there are steps you need to follow if you are installing JAMS. We just followed them and pretty much everything worked. 

The deployment took less than an hour. It was pretty quick.

We went from nothing. We just deployed all the new tasks first. So, all of the SSIS jobs that my group had built. These were all new. We didn't really have anything to convert because it was already there. That was the initial phase. That is why it was pretty quick. Once we were comfortable using it, we started to expand the use of JAMS to start converting some of the SQL Server agent jobs into JAMS.

We migrated from an on-prem JAMS to an Azure VM JAMS. So, we actually did a migration, which also involved an upgrade in the process. There was a time when we hadn't upgraded JAMS for over a year, so we were way behind. What we were told by JAMS support is to upgrade our JAMS first, then redeploy it on an Azure VM, and that went without a hitch. I was quite surprised and impressed by how easy it was. Support also said, "If you need us, we can be on the line." We scheduled some time with them, but we never really used them.

We installed the Interactive Agents once. There was an odd case where we were trying to automate a Microsoft Access script or something, which required the Interactive Agent to be installed. This took awhile because of permissions and things like that. Once it was working, it just worked like any other JAMS job. The only hassle was setting it up. We were a bit confused by the documentation. This was at least six months back, but it had something to do with the instructions not being entirely clear as to what types of authentication we had to set up. We reached out to JAMS support, and they said, "Do this." Once we did that, it worked. That was really our only exposure to the Interactive Agents.

We did it all ourselves.

It has been a while since we installed it, but we might have had someone on the line. They actually said, "If you want, we can be on the line." We might have used that, but I don't think we really needed them because it was just click, click, click, and follow the instructions.

We have an infrastructure group, but deployment for JAMS usually defaults to a single person, since he was the one who installed it in the first place. So, he has the most "knowledge" for upgrading patches.

We haven't had the requirement to go beyond our number of licenses. The way that the license is set up, we are allowed a certain number of jobs a day. That is the license that we have, which is more than enough. 

It was $10,000 for the first year. Then, there is a maintenance cost for licensing every year that we get billed $5,000 for every year.

The way that the license is set up = it will allow you to 350 jobs a day. You can install the agent on as many machines as you want, but you can only run 350 jobs a day. Then, if you want more, you pay for more.

I looked at VisualCron. The reason why I picked JAMS over VisualCron was that JAMS got back to me very quickly. VisualCron took two days. They are a much smaller company and took a couple of days before they got back to me. Because the main thing is really the type of support that I could get, JAMS won out over VisualCron, even though VisualCron ironically looks prettier. 

The JAMS client is ugly, but I got support. With VisualCron, which I think is based in Sweden, the time difference would have been difficult, whereas JAMS is somewhere within the U.S.A. In hindsight, it is probably a lot easier to use JAMS because we are the government, so it probably looked better than if I was dealing with someone from overseas. 

Before they were bought over by HelpSystems, they were just JAMS. I spent time on quite a few phone calls with their sales rep, who won me over with their level of support. 

Biggest lesson learnt: It is critical having a scheduling tool that will show you where all the jobs are and what their dependencies have been when you are doing batch jobs. In the past, SQL Server Agent jobs allowed you to do it, but you really needed the ability to look at interdependencies between jobs. That is what JAMS gives you.

The reason why I am giving it a seven is because of the UI. If they fix the UI, I would give a higher grade than seven.

It is our enterprise job scheduler. Every batch job that runs in the company runs on JAMS. 

It helps save time when troubleshooting stalled jobs. It has full logging. You go into your single pane of glass, you see all your failed jobs, you click on the job, go straight to the log, and you see what has gone wrong. And if something fails in the middle of the night, with the targeted alerting it sends an email or an SMS and does all your on-call for you. We've been using it for so long that it's hard to say how much time it saves us. But it's probably fair to say it quite easily saved us a day a week, and even more. The time saved could easily be the equivalent of one FTE. And that, of course, allows that FTE to do other work that's beneficial to the company.

One of the most valuable features is the natural language selection. That means that when you are scheduling a job, you've got more flexibility than anything else I've ever come across in the industry. You can not only tell it to run something daily or on a specify a day of the week, but you can specify "the first Monday of the month," or "the second workday of the month," or "the second business day of the month," or "the last business day of the month," or "every other Tuesday." The flexibility in the scheduling is because of JAMS' natural language selection. It's better than anything else on the market that I've seen.

The ability to change jobs is the stock standard for a job scheduler, but JAMS has the ability to allocate resources. We mainly use that at a global level. If we are doing scheduled maintenance, for example, we can halt all jobs. We can set the resource level to zero and no jobs will run. That way, we don't have to go through turning off schedules. For maintenance windows, it makes life an absolute breeze.

The alerting in it is really targeted. You can set a hierarchy of jobs if you like. There is a global level, obviously. But underneath that, you can have folders. We set up those folders at a functional level within the business. For instance, we have a folder for our finance jobs, another for our compliance jobs, and another folder for our equities jobs. At that folder level, you can set specific alerting so that if jobs in a given folder fail, certain people are alerted. You can also set security at the folder level, so that only people in those areas can go set them. That means that the alerting and security can be set at a very granular level.

Another great feature is the full auditing capability. If anyone makes a change to a job, you can see who's changed it and when. That full auditing capability is huge for compliance. And you've got version control, as well. If you make a change to a job and it fails, all you have to do is revert back to the previous version and you're back in business.

In addition, it's built on .NET. If you're a Microsoft shop, PowerShell is exposed natively and seamlessly integrates with it, which is brilliant. We use an awful lot of PowerShell in our organization because we're a Microsoft shop.

But it can run agents on any operating system and it can run all types of jobs. The execution methods it has are amazing. It can run stored procedures, SQL Agent jobs, SSIS packages, batch jobs, Linux jobs, and Oracle. The number of execution methods is huge and it runs just about any type of job you would want to run, and on any platform, which is also huge.

JAMS is also very intuitive and easy to use. It doesn't take a lot of work to set up and get started with it. It integrates natively with Windows Workflow Foundation, so you can build quite complex workflows, with if-then-else structures, and you can run things in parallel or in sequence. It really is a very feature-rich product but it's also very easy to use.

In addition, it helps centralize the management of all jobs and all your platforms and applications. You have a single pane of glass where you're looking at everything. If your organization is big, you might have multiple administrators. In that case, you set security at whatever level you like and certain people can only look at certain jobs. In my case, because I'm effectively the administrator of it in our organization, I see everything. But that one pane of glass for a whole organization is its great strength.

The only thing that they could improve on is the fact that they don't have a browser version of JAMS. They've got all the bits and pieces there if you want to build your own web version of it. It does come with a web client, but it's pretty clunky. They could improve on that.

I have been using JAMS since 2009. I was the first in the Australasian region to implement it. We're currently using version 6.5, but we're in the process of upgrading to 7.3.

The stability is really good. They do have a failover solution, which we're not using. We are just using the standalone, with a single server, but with no problems at all. We have never missed a beat.

We haven't had a problem scaling up. We have over 2,000 individual jobs, and we run 25,000 instances of those jobs every day. We plan to increase our usage as this is the only solution that runs jobs in our company.

All of IT uses it to schedule our jobs. And because of the security aspects, we make ad hoc jobs available to end-users as well. They can go in and all they're able to see, and run, only their ad hoc job. So about 50 out of the 350 people in our organization are using it.

The support is terrific. I've been working with these guys for 12 years and, as often as not, they've come across every problem that I've come across. I'll say, "Oh, listen, I've got this problem," and they'll say, "Here's a piece of code you can run. Here's an example where one of our other clients has done it before and we helped them do it." The support is brilliant; really good.

Positive

When I started with this company, they didn't have JAMS. Because I'd used it at a different company, the first thing I did when I got here was to say, "We're putting this in," and they did. They were running jobs via SQL Agent, as well as Windows Tasks Scheduler, SQL Server Reporting Services schedule, via Linux cron, and someone had even built an in-house job scheduler. Back then, when a job failed, remediating it was an absolute nightmare because nothing was synchronized. There were no dependencies on any of the jobs.

All the monitoring was done manually before, in our organization. Any company of a certain size should have an enterprise job scheduler. If you don't, you're just kidding yourself. You are making a rod for your own back, because someone has to monitor things, whether it's SQL Agent or Window Task Scheduler, to make sure the jobs are all working properly. Because it was manual, things would get missed and it was a nightmare.

The initial setup of JAMS was very straightforward. It was really good and their support staff was terrific in helping with that as well.

You get it up and running in a day, if you've got your servers built. It's a matter of provisioning a server, making sure you've got your service account set up, database ready to go or your database server provisioned. As long as you've got all the bits and pieces, you could be up and running in an hour, really.

ROI is hard to quantify. But whereas in the past we might have had one or more people monitoring batches and remediating failed batches, JAMS does all that now. It frees up one or two people. It's been an absolute no-brainer for us. It's worth its weight in gold and we cannot get rid of it now.

There was a price hike recently, which makes it a lot more expensive than what we are currently paying for it. You can do an enterprise license, which is probably the best value. But it's certainly a lot cheaper than Tivoli and Control-M. In comparison to them, you get a lot more bang for your buck. You get pretty much the whole functionality and more, in some cases, when compared to Control-M, but at a fraction of the price.

Before coming across JAMS, I had worked in bigger organizations that used Tivoli and Control-M. They are what I would call your "Tier One" solutions. Very big companies use them, although I don't know why they do, given that they're super expensive. Both of them are very feature-rich products, but in addition to being very expensive, they're very complex to set up. They also require a very heavy touch to maintain and administer. JAMS is easier to set up, much cheaper, and much easier to administer. 

There's another product called ActiveBatch, which is what I would call "Tier Two," because it's not as expensive as Tivoli and Control-M. ActiveBatch is in the same category as JAMS, price-wise. It has a nice drag-and-drop interface, which is something that JAMS doesn't have, but it's a lot more complex to use and not as intuitive.

Give it a go. Compare it to everything else on the market and, in terms of bang for your buck and the features you get, I would be very surprised if anything even comes close to JAMS.

You put an agent on every box that you want to run a job on. It's not agentless. But, as I said, you can put an agent on a Linux box or a Windows box or whatever other type of box you have and run jobs on any type of OS.

JAMS stays well ahead of the curve. I've been using it for 12 years and I still love it. I've recommended it at every company I've worked for.

Previously, all the jobs were on different platforms, so the monitoring was not centralized. That was the main challenge about two years ago. After implementing JAMS, especially in staging and production, we have one dashboard or console that we look at every day. It's easier to monitor jobs. It's efficient. We can easily track which jobs have failed. The administrator can work in a productive and proactive way. In one dashboard, we can navigate and see which jobs are running and which jobs have failed or have been successful. We also have direct email notifications. In terms of administration and monitoring, it really helps administrators to monitor 24/7 operations, and when it comes to the business, we give them the capability to monitor the jobs. They can monitor the jobs as well when they are executed in one place. They can navigate to the domain structures from different domains, and they can monitor their own servers every day.

We started with the custom dashboard just two weeks ago. It's easier for us to monitor through the custom dashboard. We're able to customize the dashboard for the things that we want to monitor.

When it comes to automation, we have already implemented a couple of scripts. For example, we have a daily agent check, so we created a PowerShell script to monitor that. Every day, that job executes and checks which jobs agents are offline or inaccessible, and it will then send an email notification to the administrator. We can then check the server status and identify why the server is offline or inaccessible. In terms of automation, we are able to work with the developers based on their requirements. We have already implemented different jobs. We have automated some of the API jobs. We have also automated the process of restarting application services.

We have different batch-processing jobs. Some of them are weekly, and some of them are monthly. We can proactively monitor all batch-processing jobs that are recurring on a weekly or monthly basis.

JAMS saves time when troubleshooting stalled jobs. When we have an issue, we check the logs and the execution history. We also have documentation of the common issues in Confluence. We did not encounter any major issues so far. We haven't had any fatal or severity one issues. They have mostly been basic issues. Most of the time, it was an execution issue. For example, we had a monthly patching activity that affected our servers at times. During patching, the server was rebooted, and the jobs that were running at that time got terminated. We had raised our concern with the JAMS team about the synchronization. When the server is rebooted or restarted, the expectation is that JAMS and the server will synchronize. We encountered this issue in the previous versions. When we upgraded the version, we did not encounter that anymore.

Using an enterprise system like JAMS to manage our jobs gives us peace of mind. In addition, we don't require many administrators for monitoring the jobs. In our current environment, there are only three of us at the moment. I'm working during the daytime, and the other two are working during the nighttime. Three of us are enough to monitor and manage JAMS. It's a time saver because you don't need to monitor it from time to time. It automatically manages everything.

The feature or capability to import a job is most valuable. We can import an existing job from different platforms, and all the configurations get migrated as well without modifying the code, job schedule, etc.

Its integration capabilities are also valuable. There is API, and then there is integration with Snowflake and Power BI. The PowerShell integration is also very powerful.

It has been good so far. We are very satisfied with JAMS' capabilities and features. When I joined the company, we migrated all the jobs from different environments, such as from SQL and Oracle databases, Cron jobs, and Windows task scheduler, to JAMS. We onboarded different departments to JAMS. The product and the business teams are very satisfied as well with how JAMS works. They especially like the self-service capability wherein they can provision or deploy their own jobs in lower environments. Developers are able to leverage different development processing jobs. They are building their own PowerShell scripts and are integrating with other applications through APIs.

The ACL or access permission area needs to be improved. When it comes to defining and providing security permissions, it's a bit confusing if you are new to JAMS. JAMS needs to improve the features for security access or permissions.

I've been using JAMS for about two years. 

From time to time, the JAMS team will update you about the latest release. So, in terms of stability, the JAMS team will support you in maintaining your system. We haven't had any issues with stability. We are very satisfied with that because when they release a new version, we are informed ahead of time. We appreciate that kind of engagement.

Its scalability seems good. We have a lot of users using it. We have 12 to 15 internal departments using it, and we have 300 to 400 users. The roles of its users vary from department to department. The most common roles are developers, QA, business analysts, and managers. In terms of maintenance, there are three of us who are managing JAMS.

Currently, in staging, we have around 500 jobs, and in production, we have close to 1,000 jobs. We don't have any plans to increase its usage at this time. If the number of servers increases, we will plan ahead of time and increase its capacity. 

We encountered a few issues, but we didn't have any major issues so far. When we encountered an issue that wasn't familiar to us or that we couldn't resolve or troubleshoot, we created a ticket. They set up a meeting session with us. We collaborated and identified the issue and documented the issue so that if we encounter the same issue in the future, we have documentation about how to fix the issue.

I'd rate their customer service a nine out of ten. We don't have any issues. When you create a ticket, a good thing is that they respond immediately. Most of the time, I go to the JAMS portal to create and submit a ticket. There's chat support that will immediately respond to your inquiry. That's a good way to submit a ticket to JAMS support. They respond immediately via chat. They also ask you to provide the logs in case of any issues. For an in-depth investigation, they will also schedule a meeting so that they can have a working session to review the issue and resolve it as soon as possible.

Positive

We didn't use any other solution previously. As far as I know, my team was managing the jobs for each platform separately. We didn't have a central solution before. This is the first time that we have an enterprise platform like JAMS.

When I joined the company, the database engineering team had already started to deploy it. It was already set up.

Our setup is standalone at the moment. We have two environments. We have the staging environment. All of our platforms are deployed in staging, and then we have a separate box for production. There is a plan for high availability. This year, we are planning to include that option and implement it.

We have on-premises deployment, and we also have a private cloud. We have Azure, and we are also exploring AWS.

I do take care of the upgrades. The upgrade process is very simple. There is online documentation. The upgrade procedure is quite similar to other solutions.

Based on what I know, we only consulted our JAMS vendor. We did not go to a third-party consultant.

We would have got an ROI, but I'm not aware of the numbers. We are still using this product, so there must be an ROI.

It was already deployed when I joined this company.

We had two internal people who evaluated it and installed it in staging and production. They learned it on their own. When I joined the company, I didn't have any prior experience with JAMS, so they gave me training, and I learned from them. The main challenge was that while learning the platform and its functionalities, we were also doing onboarding. We were migrating different jobs to JAMS, and we encountered some issues. For example, while migrating the jobs, we had to disable them because there was another phase of the project for communicating with the product team and identifying the jobs that needed to be enabled and the jobs that weren't needed anymore. So, we encountered different challenges while importing the jobs, configuring the jobs, and assigning the access permissions, but from that experience, we learned a lot. Overall, it was a good experience.

I'd rate JAMS a 10 out of 10 for its features and capabilities. In terms of features, JAMS has almost all features. JAMS can meet the needs of most companies or organizations at the moment. We don't find any limitations.