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.

All the features are valuable and we utilize all critical features of the solution, such as scheduling, automation, and notifications.

I like how you can add new execution methods on the fly. It isn't overly complex to add Python script support to an execution method in the JAMS system. The scheduling is excellent. You can schedule a maintenance window and take that resource unit out of everything. It halts all of the jobs. 

We did that when we upgraded the last time. It's helpful because we don't need to worry about upstream and downstream jobs or any triggers and kickoffs. I also like that the JAMS uses PowerShell and has a PowerShell module. 

Regarding JAMS' exception handling, I will say that the person scripting a job should try to catch those exceptions and do their own internal logic for it. JAMS will generate an error if I write a script with an exception, and it'll display that error in the log. JAMS catches it. 

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.

The ability to sequence jobs is excellent; it means we don't have to schedule them individually, and if one fails, it doesn't unwind the entire workflow.

JAMS is excellent for helping us be aware of and handle common issues that can prevent jobs from running. The solution notifies us when jobs go sideways, which is extremely helpful. Additionally, we can change our parameters if the network changes or if adjustments are made, allowing us to quickly alter a bunch of jobs just by updating a parameter. 

We use the solution's Interactive Agents; we deploy them on different servers to run the jobs directly. Adding interactive processes is very important to our organization.   

Running interactive tasks helps users focus on business processes. I'm the primary administrator for JAMS. It helps tremendously by allowing me to offload all the problems that can occur with jobs and all the associated rescheduling and rerunning of them. With JAMS, my job is much easier.  

JAMS is second to none when it comes to handling exceptions, exceptions meaning issues where a job might fail for one reason or another. I can dive into the job, and the log files are centrally located so that I can find the root cause very quickly. I can then address the issue, fix it, and rerun it all from one application.  

The platform's code-driven automation is excellent for helping us handle complex scheduling requirements. There hasn't been anything we haven't been able to do through PowerShell. 

JAMS helps us troubleshoot stalled jobs; it points us in the right direction as the centrally located log files allow us to see how far the job progressed and the specific point of failure. It gives us a good starting point for troubleshooting.  

The most valuable feature is the easily accessible data in the database because we run a lot of SQL scripting against the database.

The workflows are easy to build, and we have a lot of control over how, when, and where jobs will run, which gives us a lot of flexibility. We've been able to do everything we want in JAMS at an excellent price. We've used the solution on many different servers for many applications, so that worked well.

JAMS helps us be aware of and handle common issues that can prevent our jobs from running. We receive emails that show logs from the application, which gives us a good picture of the situation in a failure, with essential information, including the problem and what we need to do about it. 

The solution's ability to handle exceptions is complete, and we have no problems at all with that. 

The tool's code-driven automation for helping us handle complex scheduling requirements is fantastic. It addresses advanced scheduling in our workflows very well and allows us to factor in sequencing, time, dependency on other jobs, etc., giving us great flexibility. This is important to us and a significant part of the solution's capability. If we didn't have JAMS, we would have to build our own mechanisms to manage job sequencing, but JAMS provides that capability in a straightforward WYSIWYG interface that works well. 

The overall product is fantastic. I love it. It has been a fantastic, solid product. If I have one tiny bit of a problem with it, the support team gets in touch with me right away. I don't know if I've had another service that has been as fantastic as the JAMS support team. 

I find the historical tracking feature of JAMS invaluable for reviewing past events. Customizable workflows with dependencies and variables allow for more complex task management. Additionally, notifications through JIRA and excellent customer support enhance the overall experience with the software.

Being able to create a series of chained jobs, which are basically linked jobs is valuable. This means that we can schedule a server restart at 2 a.m. Once the restart is complete, we can have the job trigger another job that will send us an email notification. Then, we can have that job trigger another job that runs some SQL statements or Power BI queries. We can continue to chain jobs together in this way.

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.

I can create new jobs and schedule them based on time, based on a file trigger, or based on an email trigger. I'm happy with all those abilities.

The interface is good, and it's very easy to define and create jobs. If a job is not running or there is an error, the solution will send an email. That's all very good and very useful.

JAMS is easy to use. We came up with various scenarios for scheduling. With a little bit of thought, we figured it out and implemented it pretty simply. Calendars, building new jobs, and crisscrossing dependencies are easy to update. If something fails, we can rerun it or skip it with just a couple of mouse clicks. The information displayed on the monitor is very informative. I have a team of 24/7 operators. The team members watch it run and make sure everything's on time. If anything fails, they address it. The product is pretty good for them. It’s pretty easy. I like the solution overall.

One of the things I like the most, as a SQL DBA, is the fact that we can manipulate tables in the background. Also, the fact that you can have your own views and work with the product the way it fits best is a very helpful feature.

There are alerts if things fail, and we do have that functionality in place. For critical jobs, we also have notification that the job has run successfully. And JAMS is very good at handling exceptions. You can do retries.

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.

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.

I didn't know about JAMS because I don't have a person with any challenges with the purchase administration. The feature or the user interface is user-friendly because of the readable icons or very descriptive icons. Although I'm a beginner user of JAMS, I did not have any issues using it. 

Whenever we propose JAMS to one of our clients, we always highlight its ease of use. The interface for scheduling jobs is user-friendly. I also appreciate its strong integration with Fortra's other tools. You can integrate it with the other products to create a total automation solution. 

I rate JAMS 10 out of 10 for its ability to make us aware of and handle common issues that can prevent jobs from running. I rate JAMS nine out 10 for exception handling. You can configure exceptions to the rules in the scripts. For example, the process might not be executed on specific national holidays or days the offices are closed. 

Our clients are impressed with JAMS's ability to operate across platforms. Most of them use Linux with a combination of SSIS or Oracle packages. If it's a Windows-only solution, the support will be very limited, but most customers do not use Windows anymore. Most of them are on the Oracle and Linux side. The fact that it's a multi-platform system helps us scale up our clients.

JAMS is highly flexible in terms of error recovery and job dependencies. That's something I typically stress in our demos. The use of workflows is easy to understand. While I don't have any experience with other workload automation solutions, I think JAMS can provide this high-end feature, where you can accumulate multiple jobs at the same time with different requisitions. 

JAMS is easier to use and cheaper than our previous solution. The installation is more straightforward, and JAMS has a graphical user interface, so it's more accessible. The interactive processes are helpful. We don't use them often, but it's a nice feature to have.

It sends notifications to the person on-call when a job fails, but the failures rarely have anything to do with JAMS. It allows jobs to restart several times, which often resolves exceptions. I'm satisfied with how it handles exceptions. 

Batch scheduling and having a single pane of glass that we can track the success of all of our automations throughout the day are the most valuable features. 

JAMS is very good at helping to handle common nuisances preventing our ops from running. We set up warnings whenever a job is having trouble, and that allows us to address it before it becomes business impacting. JAMS support has always been very helpful in providing us any guidance on how to address issues.

We use their interactive agents. We use agents on a few machines. We have some automations that will run the first part and then wait for a user to release or run a second part. That is used frequently and is very useful, but we don't have a ton of straight-up interaction. We do have some users that interact with JAMS, to release jobs or kickoff new jobs after they've done their checks.

Running interactive tasks helps our users focus on their business processes. Running tasks out of JAMS really helps us to do more with less and rerun as a fairly lean organization. That helps us to maintain that leanness so that we can do more with less. Since adopting JAMS, we have been able to actually reduce staff in areas and not replace them, just because of attrition. We didn't lay people off but we didn't have to hire replacements because JAMS processes were helping.

I think JAMS has a very good engine for being able to identify exceptions. We're probably not using it to its fullest extent, but I think it has pretty good capabilities as far as handling exceptions and if a job fails, how to react to it. 

The code driven automation for helping us handle complex scheduling requirements has been great. We have somewhat complex scheduling that we need to do based on business and holiday schedules and running it on a certain business day of the month and that kind of thing, and it has been no sweat. The support at JAMS has been very helpful in helping us to use that effectively.

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.

It's a full-featured job scheduling tool. The part that I liked the best was the support team. This tool was new, and we were all learning it and setting up the different jobs that were complex in nature. Their support team was very responsive in helping us out through the setup and resolving the issues. They have been incredibly awesome.

The email notification that we received was also valuable. I liked that part because if there was any job that failed, it was good that we were notified instantly. That's one part that we liked. Also, we had to run multiple interfaces on the JAMS server, and we were able to do that very easily.

It's the best tool to schedule jobs. It's super easy and super transparent. Once you know how to set up a job, you can easily train the users. It provides excellent visibility if something fails. 

Among the most valuable features are

• the ability to define autorun jobs to pick up files and push them when they show up
• the scripting 
• PHP
• the timing.

All of these are perfect.

We also use the solution’s Interactive Agents. If we need to push something to our dealer portal, we can just drop a file in a folder and it goes. Running interactive tasks helps me users focus on business processes since I don’t have to take care of running the jobs manually.

Another useful feature is the solution’s ability to handle exceptions. If there are errors, we get notifications. 

The code-driven automation for handling complex scheduling works great. We have reports that come out and we have programs that will bust them and email them to our dealers by dealer number. JAMS helps with automation.

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.

While I appreciate the other features, the agent stands out for its ease of installation and configuration for JAMS monitoring. We can define thresholds to detect jobs running longer than usual and receive notifications when that occurs. Job monitoring is also a valuable feature for our clients.

The scheduling and execution of jobs are the most valuable features. The scheduling is important because if there is a task we want to execute at 4:00 AM, there's no way we will have someone who can manually run the job. In addition, we execute 100 to 200 jobs per day, and manual intervention is not an option.

I can also set up a workflow that repeats, which is quite good. And if there's something wrong, it will send an email notification so that we can look into it.

Most of the jobs are very critical to our internal business operations. On one hand, they need to be executed, and on the other, they need to be completed within a certain timeframe. JAMS helps split jobs out to our different agents to complete. That's really helpful.

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 most valuable feature for us is that it's DR-ready. With respect to disaster recovery, it has the built-in capability for failover to our DR site. If all of the required ports are open, it can be done seamlessly.

We test the disaster recovery capability every now and then because it is important for us to be able to failover to another site. As long as that works, if we have a problem then it's business as usual. A problem doesn't impede our work because there's no interruption in the service.

Writing the JAMS schedule is nice because we can use natural language in English. For example, we can specify days by writing "the first of March" or "the second of March". It's clear. Being able to specify the schedule in this way is good.

JAMS saves us time when it comes to troubleshooting stalled jobs because of the logging that it provides. It allows us to go to the execution history, look at the log, and find the problem. Even if the log is very large, it provides a path for us to follow and find what we need to look at. We can typically solve issues in an hour or less because of the logging.

The PowerShell integration is great. When there are things that we couldn't do out of the box, they have execution methods that we can use in PowerShell that make things more flexible for us.

The planning capabilities are most valuable. Additionally, it is very easy to use and is efficient.

In the future, it would be beneficial to have more integration.