The initial setup was complex. We had a training course that was given to us back in August but almost everybody who attended the course didn't actually get to use the product, hands-on, for about six months after the course. Nobody could really fully comprehend OpCon when we were first given the course. It was a very different product to what we were used to using. As a consequence, it was like a brand-new language and many of our staff couldn't wrap their heads around. It's not until you actually use it that you start to understand how this thing works.

Our deployment is still going on. I would say it's been a 12-month deployment with about another three months to go before we complete it. We're anticipating having it fully deployed by February of 2020.

The first part of the implementation was that we took a flatfile database dump of our current scheduling product and that was provided to SMA support, to Kevin Adams and Ben Adams. They loaded that into the OpCon database. Then we would project future schedules within OpCon and compare them to future schedules in our in-house scheduling package to see if the conversion had gone as expected. Once we found all of the different nuances, the different parts that had been interpreted incorrectly — meaning either their schedule dependencies or frequencies, probably because we exposed to them wrong — the next phase was to do parallel running.

We continued to run all of our work in our existing scheduling package and each day we would run the same schedules in OpCon but convert all of the jobs in OpCon to null jobs so that they performed no functions. They wouldn't start anything. They would just run and hopefully run in the same sequence as our live system.

The third phase was to actually start the conversion. We identified the least mission-critical jobs, the low-hanging fruit which were the least damaging jobs, and converted those. We turned them off in our in-house scheduling package and turned them on within OpCon. Once that proved to be successful, we then broke down jobs into groups to be converted, initially starting out with groups of about 100 to 200 at a time.

We've now reached the final phase, which is the remaining 3,000 or so jobs. It's a very complex schedule. We were going to implement it in stages and we're finding that it's very difficult to implement jobs that are running it OpCon while still running our old scheduling package when we have dependencies between them. So the final phase is proving to be a little bit more daunting but we're getting there.

After deployment of OpCon, it took about two-and-a-half to three months to automate our first process, between when it was communicating with the agents on the mainframe and when we actually started to run jobs.

The initial setup is really easy. Installing the product is not really difficult.

For all our infrastructure development, integration, pre-production, production, training — for the whole environment — it took about six months, including specifying all the parameters and starting the product, doing the pilot migration, testing the application after migration, and moving it to production. The first migration started immediately after we finished configuring the product.

The initial setup was pretty complex. By nature, it was complex. They had to sit down with us for a few weeks and go over how we ran our jobs. We were building that into OpCon and verifying it, and we were doing that while learning the software. It was a lot to take it on, but they were with us every step of the way and they answered all our questions. From an implementation standpoint, I don't think it could have gone better. They also had staff present from Symitar, our core, so it was like a hand-in-hand operation.

The implementation took about a month.

At first, there were a lot of meetings over the phone to go over how our infrastructure was set up and to outline all the different jobs and processes we were doing. They had different experts that we talked with to set up each part of OpCon. It was many meetings and then, onsite, it was a full week to get us ready to go.

The initial setup was quite complex. Because we have been on it for quite some time, the process to initially establish and build OpCon was substantially different than it is now. Now, if we were a new customer going onto OpCon, the process would be much simpler.

We weren't familiar a lot with the solution at the time of the initial setup. Also, it was more of a scripted program when we initially installed it. Whereas, now, even though the scripting is still there, the process of installing and upgrading is much simpler even for an initial install. A few years back, we upgraded from our really old version to a newer version. The upgrade only took a couple of hours. The initial install was two weeks of hands-on writing jobs, scripting jobs, and doing all of that. Now that they've built job functions into the program, a lot of that scripting isn't required. It's already built in.

Our first processes were automated during the initial install, but we were extremely limited at that point. We only automated maybe five percent of our daily processes. As far as regular implementation and automation of those processes, we really started getting into that and getting stuff active from a testing environment within a month or two. After a couple of months, I was familiar enough with the product to where I could start just going in and building automation. To get comfortable with the product, it took about two months.

As far as implementation strategy overall, after the initial install, we really tried to focus on the standard daily processing, such as ACHs and share drafts/checks. From there, we expanded into daily reports running for different departments. Now, we are even to the point where all of our credit card processes are automated. This is an ongoing strategy in which we try to automate as much as possible to alleviate the need for manual processing. The manual processing of files, or even file transfers, is a really big thing that we've been doing a lot recently, e.g., uploading and downloading files from third-party vendors.

The initial deployment was complex because we were migrating from our previous product and that's always going to be complex. But they did it almost seamlessly, in about six months, which was really impressive to us. We shut down the old system and turned on OpCon in one day and we were off.

The solution is used almost exclusively by the IS department to schedule our work and it's in one physical location.

The install/deploy time of our old solution and this one was pretty much the same. The process to install the software isn't much different from one product to another, generally.

As for maintenance, it is typical with any product to perform upgrades. In my role, I handle the mainframe piece, and that's pretty straightforward. We contracted with SMA to help us with maintaining the pieces that run on the other platforms, and it's all pretty straightforward and easy to do.

We had the help of the Professional Services of SMA, but the setup was not difficult. The technical installation did not take more than one day.

Our strategy was to merge all activity, from everywhere in our environment, and to have everything running from the same place.

The initial deployment was straightforward. I can complete the deployment myself.

The initial setup was pretty straightforward. We had a great team. We had both SMA and Jack Henry, which is our core vendor. They were both on-site. They worked really well together. They were very hands-on in training and had me and my team involved in the whole process.

The deployment took us two weeks. We wanted to implement it in the test first so that we could see how it interacted with our core and our other systems within our network. So that's where we first installed it so that we could do our basic setup and testing. And then once those testing passed, then we set aside some time to set it up in a production environment. Because we obviously didn't just didn't want to gung ho and go back into production.

We migrated from a mainframe-based solution using a proprietary database to a Windows-based solution using a SQL Server database. Given the enormity of this level of change, the transition and setup were remarkably smooth. I consider this to have been a straightforward setup.

There was a lot of work involved in the deployment but it was straightforward.

The initial setup was pretty straightforward. It's a nice piece of software that gets installed. There's a database configuration with a the support crew. 

We scheduled the deployment for a day, and it took just a few hours.

It didn't take so long to put it together. It was pretty simplistic. It took maybe 30 minutes to an hour to get something in there and test it out to the point where we were happy with how it was operating, then using it going forward and making any changes. Initially, it probably took 30 to 60 minutes to get something in there (the first time). That's mostly going through testing as well as developing. It isn't just putting it in there. Putting it in there, you could probably get a reasonable schedule defined in less than 10 minutes. But, if you're talking about running it, fixing errors, etc. related to scripts, not necessarily related OpCon, it takes probably about 30 to 60 minutes. Nowadays, setting something up, it takes me less than 10 minutes to define a simple or basic process.

The vendor handled most of the setup but it's more complex than other systems. We had some issues with setting up our service users with the domain. There is still some complexity with that — with which users have to run which jobs on which servers — because of permission models. That was the only thing that really was complex about the install. Actually installing the application is very straightforward, but the permissions model behind the service accounts is complex.

The complexity is because they allow you to do things in so many different ways. They didn't want to make an out-of-the-box setting for how you do things. Some of it is left up to the user to figure out the best way to handle things. In our case, we decided to use an Active Directory domain user and it was a little more complicated to do that because of security issues.

The installation itself, to where there was a usable product, took about two hours with their support team. Our experience with them during the initial deployment was very good.

After the initial deployment, it took about 10 minutes to automate our first process.

As for our deployment plan, we had all our manual jobs in a checklist and we ranked them all with a complexity rating. While the OpCon support was on site for our implementation and we had their attention, we worked through the more complex issues. After they left, we picked up the low-hanging fruit.

The setup was relatively straightforward, but we had someone from SMA on-site, so they walked us through it and showed us how to automate some of our more complex processes. I think the whole setup took two weeks. 

For maintenance, it only takes two or three people in IT. Everybody else has access to it, but we have a core group that maintains it, and then there are around half a dozen to a dozen self-service business users. But from a day-to-day perspective, it's low maintenance. If you're not changing anything, you don't have to do anything. If you're setting up new processes, that takes a little work, but you don't have to babysit the solution.

I didn't participate in the setup, but I believe that it was straightforward. OpCon came onsite for training and it seems that soon after my staff got the training they took the ball and ran with it. They got the building blocks in the training and, after that, they caught on fairly well and were able to start automating a lot of the manual processes, one by one.

For the implementation, we had to load the server and we had to have a backup for that OpCon server, which goes out to our Branson site. Any changes to OpCon get passed on. But when OpCon come onsite, they pretty much got everything loaded for us. We were paying them to do that, which is what I would recommend to anybody. It helped us, a company that was brand-new to it, to bring us into it. When they were onsite they handled 90 percent of it.

It wasn't long after the deployment that we automated the first process. Within a week we were already automating some things that we had been manually moving over. And then we road-mapped big ones like the ACH stuff that I mentioned elsewhere. One of our first projects was automating our ACH to the Feds. We had an idea of what we wanted to do once it was implemented.

The initial setup was easy, as are the updates. It took us about an hour to do it, given the way that it's all written down for you. You can have a resource from them onsite if you want or you just load the software and it goes off and does it all for you. We've done it numerous times and we've never had a problem.

In terms of our deployment strategy, we already had an SMA product called Scheduler. What we did was we took a copy of our database, gave it to SMA, and they migrated it through into OpCon for us. They gave it to us and let us play with it, test it, and make sure it was working okay and then we migrated straight over to it. It was as simple as that. We couldn't find any problems and we migrated straight away. We've never had any problems with it.

SMA is fantastic to work with. They're knowledgeable, they know the products, and they don't try and force anything upon us. They're happy to work with us. They understand our limitations, and they still do to this day.

SMA was onsite to implement the software initially. Largely, this was straightforward and any bugs or issues that came up we were able to work through shortly after SMA left. 

The initial setup was fairly complex, but we had great support from OpCon. They came onsite and helped us set everything up. From that aspect, it was very easy because we had them here helping us and working through all the issues. Once we went live with it, they were available again to help us make sure everything was working okay, and that moving forward, everything stayed working.

The deployment of OpCon took about three to four weeks. This deployment was tremendously faster than our previous automation tool, which took almost a year to get in place completely. Even then, we still struggled with issues (with our previous solution).

We did the deployment of the solution at the same time that we were setting up processes and automating it. We went live with OpCon about two months after we'd finished the implementation.

We were in the process of converting, not just our scheduler, but all of our core systems at the same time. So, we were doing everything at once. Our plan and schedule was to get it to work as fast as possible, then move onto the next thing that we had to get working.

The initial setup was straightforward.

When we first started, the deployment took about one week, and that includes training from SMA OpCon as well as Jack Henry Symitar. After that, all the upgrades take about two days.

Many of the other solutions I've used require a lot of scripting and coding. OpCon is more a GUI interface and I was able to get a lot of my team training on this with ease, without sending them to any classes. A lot of my team members can build jobs, from simple to complex, with SMA OpCon, without going to any additional classes.

It's very efficient and straightforward to implement a new job. If I get a request today, I can do it within the hour and have it ready to run. That's how simple it is. I don't need four hours' advanced notice. We started deploying things ourselves immediately after training. They came in and trained us, created some sample jobs for us, and we took the sample jobs and were able to recreate them. We just followed the steps and started applying them. That feature, where we can copy one job to another, is great.

As for our implementation strategy, we have a live system and we had a test system, so we built two systems. We started to build the schedule and the jobs on pre-prod system. Once everything was tested we went live, and we kept the test system for any other testing that we might need to do. Eventually, we got rid of the test system because we were able to do everything on the live system. We're able to test a job — not actually run it, but test it — before we deploy it.

I was not here for this bank's initial setup, but I was previously involved with the setup of OpCon at another bank.

I've worked at five different banks and each bank operates differently in the way they have things locked down or how things are completed for projects. The setup was pretty straightforward. You just get the database and application up and running, and then, the mainframe agent up and running, which is especially important for a bank,. 

The database and mainframe side of the setup are always sort of tricky no matter what application you're working with, but it was pretty straightforward. It was up and running, then we trained and helped start to set up things for how we wanted to move forward. So, I thought it was good.

The deployment took about a day, but the bank that I worked for was very locked down when, e.g., trying to get things to open up and the right resources from SQL DBA. But, the actual application on the mainframe side, that's a no-brainer and seamless.

It took a couple weeks to deploy our first process because you have to test and get comfortable with it. We only automated a couple core things at the time because the main focus of getting OpCon in the bank was that they wanted a very cumbersome process streamlined.

At my current organization, I know that deploying the first process took them a couple months because they wanted to a lot of testing before they implemented it.

My implementation strategy is going for the easy stuff first to get a feel for it. Then, I can quickly turn things around on a small scale. Afterwards, I will graduate to that larger scale. With each implementation that I did, I evolved myself and how I wanted to do it, what I learned, etc. Because the other bank versus this bank were on two different mainframes, I had to translate a bit and think through things differently. I like doing the smaller things first, but now that I'm two and a half years into it overall, I can chew off the big things right away too. I'm not afraid of them, and they're fun, exciting, and more thrilling than the easier stuff.

I wasn't quite involved with the installation piece of it. We wrote a Unix script for it.

It took us minutes to automate our first process.

It's very flexible and pretty easy to use. You can go into complex modes if you have to for complex jobs. It depends on what's needed. Most of it is very simple to use and setup. You do need a logical brain to understand what you are doing in some way as you can get lost in some of the features and options, like setting up dependencies and thresholds. If you're not aware of what's really happening, you can mess those up pretty badly. However, as long as you know what you're doing, it's pretty easy.

Back then, the setup was complex because of the number of processes that we initially automated. Our initial deployment took about five months. The installation of the software took a day, and then we spent several months creating our automation, within the tool.

The initial setup was a bit complex, but we had great support which helped a lot. I made a lost of mistakes in the beginning, so I learned the hard way. But now, I think I manage OpCon quite well. We aren't make beginner's mistakes now. OpCon used to be quite difficult but there was a lot to learn.

All the ideas and concepts behind the solution can be difficult to understand. E.g., I hadn't used a scheduler before. This was the first time. But, we had a lot of help, so it was okay. I tried to learn it myself using trial and error. This was quite a good way to learn and understand how it works.

The full deployment was around one year because I didn't want to move everything since nothing would have worked afterward. So, we took our time and did our mistakes, which was really important. After one year, we were fully operational. Our IT moved during that time, so some jobs needed to be canceled or removed and new software needed to be included in OpCon. By the time we had OpCon, all the new jobs were included. We talked with software editors and told them we had a scheduler to run jobs daily.

Every new software is included in OpCon, so it just works. All my colleagues know it's there and rely on it.

Our initial implementation strategy was to start big, but we went slowly. We took the biggest server that includes our biggest data and started to process those jobs. We took time to look at whether the solution was working and to correct our mistakes. After one month, the server was fully integrated with OpCon. We had monthly schedules, so we had to wait for one month to have everything run. So, it took one month for our first big steps.

After that, it was easy to incorporate all other tasks and jobs. Most of the time, it just took time because we had to rewrite the scripts behind the jobs. In the beginning, OpCon worked, but the scripts had to be improved. Therefore, we took time to rewrite them, making them more reliable and able to work with OpCon's written codes. We made great efforts to use the same way to write our scripts. Thus, it took time, not only for the jobs, but for the scripts behind it.

The first day that OpCon was working we had our first job working on it.

The initial setup was a learning curve. We had that three month trial and SMA sent somebody for three days to come out and train us and to do our initial setup. We told him this is what we want to do and these are the jobs that we want to automate. He sat with us and mapped out a solution. We worked with him and got hands-on knowledge of it.

It was pretty straightforward after we got through the learning curve. I'm a mainframe person and I come from a world where there is a terminal emulator and you're setting up workflows that are writing code, and that's how you would set up your job. When you go to something where you can just point, click, point, click, and add a few lines, that's totally different. So we had to be retrained and retooled when we first went to this product.

They have extensive documentation and training materials, right down to error codes and troubleshooting.

Our initial deployment was a matter of a week and we were running automations. As we moved forward, after we purchased the product, we expanded it and put more automation into the tool.

Our implementation strategy was based on the use cases that we wanted to solve. I saw how bogged down the operations staff were. When we were looking at the strategy of what we were going to put in the automation for the trial period, we focused on our biggest jobs and the ones that were most time-consuming.

The initial setup was complex, however, the SMA Technologies consultants are there the whole time, guiding the process, and making sure you'll have success. 

Deployment would not take very long now, with the way they have the install set up.

We usually do a test server to start with, just to make sure everything went well before we do production. This last one took about an hour or two on the test side. We ran into something with updating the database. It was something on our side that the database administrators had locked down, so it wasn't working quite right between when we installed in test and installed in production; they had tightened the permissions down. Other than that, it takes us about an hour to get through what we need done.

My implementation strategy for deploying it for the first time would be to put it to test in our test database, and then grab a few jobs from each type of job we run and see how it works with the test database. I would then check with the developers that everything looks like it ran okay and then we would take a weekend and deploy it to production. Of course, we would do testing there as well. Since it's VM, we just have the VM guys ramp up a new server, so it's always a new install and, if it doesn't work, we can always fall back to the old version and the old server.

For deployment, we usually bring two of us in, and that's it. For maintenance of OpCon, we only have one or two people, as backup. We have operators per shift who actually run it, but for maintenance there are only a couple of people. One of them is me, in my role as a data center manager, and the second individual is part of my staff.

In terms of the number of users of OpCon, the numbers have dropped now that we're moving off of mainframe, but we'll be picking back up. Currently there are about 100 programmers that could possibly have access. We don't have that many yet in Self Service. And there are 12 on our staff that use it, including a couple of admins, a couple of implementation people, and the rest are operators.

At the time, I was number two in terms of setting it up. My manager was the key person in rolling it out. I was working to keep the lights on and to keep the business going while he was learning about OpCon and doing the setup. He got let go and it became my responsibility.

My manager worked on it for about one-and-a-half years before he was let go, and at that time we probably had 1,000 jobs running, in total, every two weeks. And out of that, we really didn't have a high success rate. He didn't share some of the key utilities with us so that we could work on it. When he got let go we got the entire, "Here's the product. Do it." We were able to figure out the problems. He had set stuff up initially but he had more test stuff in there than he had production stuff. Once I figured out what he was doing, it didn't take me a week or 10 days to start making changes.

He didn't have it working perfectly, and it took me about two months to correct some of the issues that he had and actually make it worthwhile. Now, I've got myself and five others trained, and it's really doing a lot for us.

We're up around 94 or 95 percent success on jobs that run.

We've done a couple of upgrades, and their upgrades are getting simpler. The more stuff that comes out, the easier it does get.

Given that it's running, eventually I'll have to have one person for each shift just to monitor it. When we do deploy some of the new SLAs and some of the new features that are in 19.0, we will be able to even better manage it. Eventually, someday, we'll be a lights-out organization.

I was involved in initial setup in my other job a long time ago. It was relatively complex, but SMA does it for you. From that standpoint, it made the initial setup straightforward for me.

For the two employers that I have done this solution with, the strategy was to identify the most important processes that we wished to have automated. It might be important because of the process's criticality to the company or because of how annoying it is to have to do it every day. Those are identified, then documentation is gathered together. It might also be information inside people's heads. So, you have to do some interviews or onboarding meetings where you get the information together required to make it able to be automated. You work with an SMA engineer to do the initial automation along with training, then you place it into production. My strategy from there is to use the onsite expertise to help identify the next tier of things that should be automated so we can work on them ourselves as we go forward.

When I started here, the OpCon was in production already. I am not sure about the complexity of the setup.

The initial setup is very complex, but that's not necessarily something that needs to be improved. I'm told that in the next version they're improving the upgrade process. So that's in the works already. 

It integrates fairly well with things like basic scripting programs which is good. 

OpCon is very powerful. That means it tends to be very complex. It doesn't always translate to usability. You can do anything in any way if you have the time and the knowledge, but it can be tricky figuring out how it's done. I haven't used much of the APIs other than some of the connectors, but I hear they've got some good support that way. I don't have any one thing that I'd say would be an improvement upon it except for perhaps making the calendar, the scheduling functionality a bit more intuitive. Some of the ways that they implement the calendar functions aren't as intuitive as they could be.

For some jobs, the setup is very straightforward. For others, they required more complexity. I have some that when we first set it up, the complex ones were downloading our federal reserve files and processing those, but the technical account manager that assisted was great with working with us on that. 

Having them there with implementing it certainly is required. But beyond that, the people that I've encountered, even when I was at a previous employer, were always very good at helping us get through what we needed to do.

There have been times that I've sent in a question to their support and I'll get a couple of different people emailing me back saying, "Oh yeah, I heard about this. Have you tried this?" Everyone's very active in trying to assist clients if they have some expertise there.

We worked with both our SMA technical account managers and then we were assigned someone through Jack Henry Symitar Episys, through their automation group. 

Once we got everything implemented, I had time with my technical account manager to set things up, but prior, I had time with our core provider and their implementation specialist to go through our nightly processing the critical stuff and making sure we had everything set up. That was the baseline process to get us started. After that, it was up to us what we wanted it to automate.

They took care of our nightly processing and then our account manager helped me do some of the daily processes. Since I already had previous experience, there were a lot of things I felt that I could do. He'd come up with solutions for the things I didn't feel that way for.

The deployment took a week.

OpCon was much easier and quicker to set up than our previous solution because we could set up schedules and copy them over, using them for other functions easily. Overall, it was 50 percent easier.

We were still running things on the Unisys system on a daily basis. So, we would copy our files over to the OpCon system, then run them through a simulated update just like we had on Unisys and compare the results.

The initial setup was straightforward and the learning curve was that after a few days building things in our test environment we rapidly moved jobs to live.

The initial setup was complex. There's so much it can do. But we had a lot of support from SMA, so we got what we needed. That complexity goes back, in large part, to the command-line issue. The simple things, like downloading a file and saving it, are really easy. But if you want to do more stuff, it takes a little while to get through that and to understand how it works.

SMA came onsite for the initial week and set it all up. We went live right away with several things at that point.

Our implementation strategy for OpCon was to get the nightly processing stuff set up. That was the most important initial goal. Then we made a list of all the things that were run by people manually and we went down that list.

The initial setup was pretty straightforward. The SMA group came out onsite to assist with the implementation. It was done in two phases, upon our request, because we didn't have the man-hours to be able to do it all in one shot. They came out and did some initial training with us and then we asked them to come back four weeks later. Upon their return, because of the training we received, we were able to tackle a lot of the automated processes and they helped us with the more complex schedules.

The deployment itself took a couple of hours.

The implementation strategy for us was to tackle the nightly process first, and the second item was to tackle all FTPs. The third was to tackle the complex scripting for all other SQL or AIX. The last step was to do Self Service.

The initial setup is pretty straightforward. They give you some good user guides and information on how to do it.

If we are upgrading, it probably takes about two to three hours. We start the automation process within this two to three hour time slot. It is pretty quick.

When deploying a new version, we have to do a lot of testing. We have DR boxes which we do our testing on first. That's what we're currently doing it at the moment. Then, we have to run it through our change management to make sure all of the various other areas in the department are happy.

The setup is a little complex. We couldn't have done it on our own. You must work with SMA to get set up and have training, but once you become familiar with it you should be good to go. The only time we consult them now is when we are upgrading to a new version. The instructions have never allowed us to do it on our own.

The initial setup is easy, and I would rate it a seven out of ten because there were some difficulties. It took 30 minutes to deploy the solution. It only required one person to deploy.

If I had been coming into automation cold, and OpCon was the first thing I had seen, I think I would have found it a little complex to understand. But since this is the third automation tool in my career, it was a matter of just applying what I already knew, as fundamentals, to how OpCon does things.

One thing that really helps is that SMA sends a technical account manager onsite to help you do the installation and do your configuration. They give you a block of days and you can split that up so that they will come back. Our technical account manager came out three times and, each time, we did something a little more complex with OpCon. By the time he left, the third time he was here, we had not only the basic stuff installed and ready to go, but the more sophisticated stuff, like LDAP integration, the Solution Manager, Self Service, Resource Manager — the different pieces of OpCon that were more complex or more subtle. The value is that SMA guides you through that. They provide that kind of onsite assistance.

Our deployment started in February of 2017 and we went live in October of 2017. After the initial deployment, it took us just a couple of minutes to automate our first process.

The initial setup wasn't difficult. It was pretty straightforward. The install wizard is easy to follow and there weren't a lot of hidden things to look for. We also had SMA staff on site, so they made it easier.

Our initial install was done in about an hour-and-a-half to two hours.

Because this is part of a conversion project, it's been managed by a PMO, and we follow a scrum-board, sprint-style implementation plan. That's pretty standard though.

Our first process was automated in about 10 minutes after install. The first one we did was one of the easiest things and it was done in a second. It was very fast.

The initial setup can be complex, however, transitioning with the MAS team was very easy and straightforward. 

The initial setup is complex. The first pieces of it, while they weren't really easy, went off well. When we got into the FTP processing, it got a little bit more bumpy. The deployment, overall, was an iterative process. We started in January and went live with the first step in June.

It was pretty easy to put our first processes together. It was just a matter of making sure they were fully tested and that we had the right test environment to make it work.

We have about five people who are working on it right now, since our deployment is ongoing.

I would like to have seen a little bit more of a plan at the beginning. SMA should have been guiding us through the process of automating these things in the most efficient way possible.

The setup looks complex, but it becomes simplistic relatively quickly. E.g., looking at a job to edit and change things, you have different setups. One of them might be running a core/FTP job, where you have essentially have three to four different selections within those or you can choose command line. 

The initial setup was pretty straightforward. We were a very small IT shop when I first came here and OpCon was one of the first SQL databases that we had that had any great importance in our world. We had local New Zealand support to help us. They were really good. We were a little bit wary of jumping in and using it, and they really helped us to step into the product with small steps to start off with. That allowed us to gain a comfort level. It was a good implementation.

We were a little bit shy and timid about automating things. We started out playing with it quite a bit. It took us a while from the time we deployed it until we automated our first process, and that was because I decided to approach it by rewriting a lot of the code that we ran, to make the best use of OpCon. We used to have one great big job that ran everything, and I really wanted to break it down and use OpCon to bring everything to the surface, rather than it being all hidden in one big job. My wanting to do that made it take longer; it was a few months to really get something going "in anger."

The game plan was to try and take away as much of the manual processing as we could. There was a lot of checking that was done every single day.

Because we had an expert here from SMA, it was somewhat straightforward. He knew what he was doing and we had confidence in him. We didn't have any problems that I recall.

We started automating our first process on the second day of the deployment. We created some schedules and jobs that ran so that we could make sure that they worked.

An example is End-of-Day. That is a program that's done on the core banking system at the end of the day and it closes out a lot of information for accounting purposes and so forth, and then sets the date to the next day. For example, certain accounts might need dividends applied to them or loan interest charged on loans. Late notices and certificate notices need to be prepared. If it's the end of the month, there may be a statement file that goes to another vendor. We need to make sure that End-of-Day is successful. We could see the next day that yes, it was. We immediately kicked in and started getting things done.

After the OpCon person left, my systems administrator started to create new job schedules for some of the other processes that we did. One-by-one, we started moving our manual processes over to Keystone until they were all done.

I was involved in the initial setup, but that was back in 2013. I was excited at the time, but wasn't sure what I was getting into. The initial setup was complex because it was something I knew I wanted, but didn't know what it was.

When we first set it up, we requested a book of jobs to be done for us. This was like a set standard of batch jobs that would need to be automated. I have been able to elaborate and expand on those.

It took us a week after deployment of OpCon to automate our first process.

Our implementation strategy was to first start simple, then go into our complex processes. 

Simple for us would be running a batch job that has maximum three or four prompts in it. Then, we go complex with the RACH process, where we receive files, process those files, and schedule times for them to post. Then, we run intermittent jobs in-between to produce a return file that goes back out. 

I was not around for the setup and it's been so long since it was done that I don't think our experience would be indicative for anybody else.

For the most part, upgrades are pretty straightforward. And they've been pretty solid too. We generally do them with the help of SMA consultants.

The initial setup was pretty straightforward. We knew what we were getting. When we finally made the decision to purchase it, our rep reached out to us and told us exactly what was going to be happening with the implementation and when he was going to show up. We got that all scheduled, he showed up, and everything took off from there.

Our experience with the SMA tech during implementation was awesome. He was very knowledgeable. He had years of experience in the field that we are in. The gentleman who came out to us had worked in IBM for many years as a programmer, so he knew what we were doing and how we were trying to do it. He was able to take the processes that we were already doing and develop them after we got OpCon in place. He came out for one week of just implementation of OpCon, and then he came out for a second week to develop these things. He was very resourceful and knowledgeable, and if he didn't know the answer, he found it within a reasonable amount time.

Technically, OpCon was up and running on the first day, but we were still moving things into it during that first week. Within a week we had processes that were being automated. It wasn't long at all. We already had a good understanding of what was happening. We just took what was happening and moved it into OpCon. As long as we had file permissions, it wasn't an issue.

Our major focus was on our core processing. Our core has numerous file moves and transfers and hundreds of jobs that run every day. We wanted to automate the nightly process and include the jobs that were running on the core all day. We took those processes and migrated them over from the IBM Advanced Job Scheduler into OpCon. That was our immediate focus. From there, we branched out and started doing the stuff that was happening on the Window Servers. We moved all of that over into OpCon, including FTP from our core vendor, as well as the moving and posting of files.

The initial setup was straightforward. We set up the original server as well as the ones that we would need it connected to. The basic system has been in place since the initial setup.

We had folks onsite for two weeks, but we have been continuing to automate more new, existing processes over the last three years. So, we had the bulk of our official setup done within three months.

After deploying the solution, it took us 10 minutes to automate our first process. After we got it setup, creating a job is very simple.

In general, getting up and running is extremely easy. Once you get the basics installed, creating and running jobs is very easy. However, when you get into the more complicated, advanced features, then it becomes much more complicated.

The initial setup is very simple. When we decided to install OpCon, this was done in two hours and two jobs could be executed directly afterward. For the other two solutions that we tried it was much more difficult, quite incomprehensible, and nothing worked as a result.

The initial setup seemed fairly straightforward to begin with, but we didn't get into a lot of the more complicated features. We've grown into those features over the years. It was just set up to do the basic processing in the beginning.

Jack Henry, the vendor of Symitar, came onsite when we converted and they were here for a week. At that point we had all of our main, "good night" tasks and the like in OpCon. Gradually, over time, we've added everything else, such as our mortgage processing, which is outside of Jack Henry software. We purchased an API and we were able to automate all of that processing with OpCon also.

The SMA techs were really good to work with. They're very responsive. We didn't have any complaints about them.

After OpCon was deployed we automated our first processes right away.

Our strategy was to make sure we had no manual processes by the end. And going forward, we wouldn't take on processes unless we were able to automate them with OpCon.