What's in store for Dime.Scheduler in 2020

February 4, 2020

Hendrik Bulens

With Dime.Scheduler's latest release, version 2019.7.0, we have reached an important milestone. We implemented the most-requested features and items that were on the roadmap for quite some time. With all these things in the bag, it's time for us to have a look into the future. In this post, we will elaborate on the areas that we intend to work on in 2020 and beyond.

A little retrospective

Let's get one thing straight from the start: this is not a New Year's resolution. Neither is it going to be a ritual that many people and companies do at this time of year. It just happens to be a time where we have to consider the next steps for the solution. You see, we've come a long way since we made the switch from the SilverLight-based version. Many features have been added since then, but a thorough gap analysis revealed that there were still some items missing from the product, which were required to make the product feature-complete. Among a few other topics, bridging these gaps was our focus for 2019. When we look back at the things we accomplished, it becomes clear that we covered quite some ground. To give you an idea, here are some of the features that have been added in 2019:

• Time slots
• Capacity pivot grid
• Task containers
• Recurring appointments
• Advanced filters
• Route sequence component
• Store application settings in the user profile
• Bulk select pins on the map
• Resource location mode
• New documentation platform
• On-premise Business Central Connector
• Bulk select appointments on the planning board
• Azure SQL support
• Highlight planned tasks
• Copy data

Cynical readers might have used air quotes when they read Dime.Scheduler is feature-complete. Due to its versatility, the solution is used in the most diverse ways. Although this is by design, it makes it pretty hard for us to design functionality that works for everybody. No matter what we do, somebody in our partner network will come up with a new and better idea that we should develop. It is like this scene from Malcolm in the Middle where Hal wants to replace a light bulb and ends up fixing the car, not having replaced the light bulb. This is just to say that we realize that no product is ever entirely complete(d). That just means our product is alive and well, and that's fine with us.

The release of version 2019.7.0 heralds the end of the development cycle for the second generation (the first being the SilverLight-based version) of Dime.Scheduler. The product team has been intensely debating on how the third generation should look like. We used the feedback from our partners, end customers, development team and general trends in the industry to define the next steps. In what follows is the result of these discussions.

At this point, we should make it clear that this is a statement of intent rather than a commitment. They don't necessarily rule out other items; like the product, we can be pretty flexible when new opportunities arise. In fact, we appreciate your input and encourage you to keep us in the loop, and who knows we can do something for you on short notice to help you close a deal.

Defining the new objectives for Dime.Scheduler

To take the software to the next level, we spared no effort. We went through the list of all the requests we've ever received, we had protracted whiteboard meetings and brainstorm sessions in musty meeting rooms, we sent the development team out on a Google search mission to find all there is to find on technology trends, we grilled our sales and management team to finetune our market, and so on. It's safe to say we've done our research and the objectives we will lay out here should be pretty close to what the market wants and will need in the coming years.

We identified five categories that cover these objectives. In no particular order, here they are:

• Maturity
• Integration
• Automation
• Enhanced features
• Cloud

In the next sections, we will go in detail what our goal is and how we want to achieve them.

Maturity

This objective - as the name suggests - refers to making the solution more mature. Adding features of a smaller magnitude will probably not make or break any deals but it will improve the overall user experience. Be aware that this not only applies to the end users: we also aim to improve the experience of consultants, system administrators, sales people, etc. Heck, it even applies to the developers who make the software!

Below is a non-exhaustive list of items that we aim to address:

• For the end customers:
  • Small enhancements to the user experience (UX)
  • Add guides to the documentation
  • Automation of the training materials
  • Business Central Connector on AppSource
• For the consultants / system administrators:
  • Reduce complexity of the installation process
  • Automation of the training contents
• For the sales people:
  • Easy access to and setup of demo environments

Another important subcategory revolves around performance. Performance is always on our minds. Some of our developers have turned into little old ladies after having worked countless hours on a solution that strikes a balance between stability, performance, installation complexity, licensing, and many other factors. One way we can achieve great performance improvements is by "simply" porting the solution to the .NET Core platform. Although it's mostly technical mumbo jumbo, it has a few added benefits. One of them is containerization, which means that the software can be wrapped in a self-contained unit without much fuss.

Integration

One of the corner stones of Dime.Scheduler is its effortless ability of integrating with systems like Microsoft Dynamics NAV or Microsoft Dynamics 365 Business Central. We will keep on investing in these ecosystems (for instance, the Dynamics 365 Business Central connector will be published on AppSource later this year) but we will also explore new areas in which the solution can be used.

We will investigate how we can tap into Microsoft's thriving cloud landscape and its increasingly impressive power tools. To illustrate this, by using nothing but Power Apps and Flow we could build a stand-alone connector that feeds data from an Excel sheet into Dime.Scheduler. The jury's still out on the how but we intend to make a stand-alone connector for those who don't need or want to use an ERP system. A similar remark can be made for the Exchange connector, which we've wanted to redesign for a good while now.

We're still in a very early stage so the implementation may differ from the design we have today. Make sure to reach out to us if you have any special requirements.

Automation

This is a biggie. It's arguably the one that we've wanted to do for years. How nice wouldn't it be if Dime.Scheduler could take a few parameters (like skills, geographic location, traffic, availability, etc.) and churn out an optimized planning? Say goodbye to manual planning as machines will take on this burden. It is our ultimate goal to provide such an intelligent solution, but it might take a little while to get there. I wouldn't count on it in 2020, let's talk in 2021.

Something that we are likely to create this year are the appointment containers. You may remember we did something similar last year with the task containers. Well, it's pretty much the same thing for the planning board: it enables the planner to collect appointments and treat them as one entity. It is a lightweight concept with heaps of applications. For example, if an appointment is delayed by two hours, then the other appointments in the container could be delayed as well. Possibly the algorithm could take traffic time into account. Frankly, it's hard to say where this concept will lead us because there are so many potential applications of this concept.

Another item on our roadmap is the advanced visual planning through the map, which is especially interesting for organizations in the logistics industry. The map and route sequence components are often used to assemble one or more trips. We will add a connection between the route sequence component and the planning board so planners can plan based on trips rather than (unordered) sequences of tasks. An optimized trip button somewhere in the planning view - that takes traffic time into account - should be the icing on the cake.

As you may know, we usually ship such features in smaller increments. Every new release of the product will contain fully functioning features, albeit not always complete. This process allows us to consistently deliver software according to our own quality specifications and it enables us to adjust quickly, if needed.

Enhanced features

The next category is a continuation of what we've been doing for the last years: adding and extending features. They are tools for the planner in the (manual) planning process. These features will not change the identity of the product; usually such features will result in more buttons and configuration items. Clearly this is not entirely true but you get the idea: it will make the planner's job a whole bunch easier.

For instance, we have been working on a concept that could be best described as "ad-hoc time slots", which are similar to the overrides in the calendar setup. Here's an example that should clarify what we're on about: if a resource gets sick or is unavailable for the day, these special time slots can be used so the planner can modify the planning accordingly. Adding such a time slot will automatically recalculate the affected appointments. If we think ahead for a second, imagine the power of appointment containers in such situations: when a resource shows up late for work, the planner inserts a time slot to reflect this infidelity, producing a modification in the availability of the resource which in turn will result in a revised planning. So instead of having finished his work on a glorious Friday evening, the resource will have to go back to the customer the next Monday to finish the job.

Other much-requested items are export and reporting capabilities, among many others. Besides providing out of the box export capabilities inside the planning view (a usual suspect is export to Excel), we will also investigate the possibilities of creating a reporting framework on top of PowerBI. Having proved quite popular in the past, we will further add new copy and paste features, like enabling cross-planning board interactions.

Besides these all-purpose functions, we also aim to deepen our knowledge in the business processes across industries. Undoubtedly this will provide us new insights on the way Dime.Scheduler is used and how it fits in the grand scheme of things. We will use this newly obtained knowledge to create specialized functions that would serve those industries well.

This is another call to action: keep those requests and suggestions coming. The most-requested items are bumped up and will be handled before the others.

Cloud

The final category needs very little introduction, and yet it is subject to misinterpretation. What constitutes a cloud application? Even though cynics use this rhetorical question to answer something like "something that doesn't run on my hardware", it is a very valid question indeed. What customers expect varies significantly; some want everything but the kitchen sink while others just don't want to own any hardware to run their software.

This begs the question: how on God's green earth do we design Dime.Scheduler to support all these scenarios? It will require our product and development team to work their magic. But more importantly, what do we fancy? Honestly, nothing has been set in stone so far. Let's have a look at the cloud flavors.

Most development teams seem to follow the same migration track:

1. Lift and shift
2. Utilize PaaS services
3. Convert to SaaS by implementing multi-tenancy in the application

The jury is still out whether Dime.Scheduler will follow the same path. The first stage is certainly feasible and bears little risk. Very little changes to the solution are required to run Dime.Scheduler off-premises. This is why this is called the "lift and shift" phase; simply migrate what you've got and run it with the least changes necessary. For many customers, this will be sufficient. However, it won't necessarily be as cost-effective as it can be. That said however, it will be cheaper than an on-premise instance nonetheless.

In this stage we will have to deploy the solution on an Azure Virtual Machine and optionally Azure SQL databases (recommended). Virtual machines have been the norm for years but they are not a specialized service and thus not a very efficient service. If you don't know why that is, a quick Google search "IaaS vs PaaS" will give you all the answers you will ever need. To reduce the costs and increase the efficiency, cloud services are a good (if not the) way to go. Services like Azure App Service, Azure Functions, Azure Service Bus, Azure Kubernetes Services, etc. can all contribute to a world-class, cloud-first application. Adoption of these services effectively morphs Dime.Scheduler into a cloud-first solution. However, this brings us at a crossroads: will we keep supporting an on-premise only version or will a hybrid setup be the default solution? This question - among many others - will have to be analyzed by our product team.

Finally, it's too soon to tell whether we'll pursue Dime.Scheduler as a Service (DSaaS). If the solution had been a simple one, this would've been a no-brainer. Because of its complexity and moving parts, we'll have to investigate this matter and await feedback from the community. So far we've received very mixed responses: some of our eager partners can't wait while others are more reluctant and like to keep their data and software on-premise.

The 2020 roadmap

Now that we've defined our objectives, let's have a look at the timeline. We will stick to quarterly estimates but we will keep you up to date through our press releases in the "what's next" section.

Remember that this roadmap is a statement of intent, it is not a commitment as priorities may shift. However, we like to stick to a certain plan as this enables us to look ahead and design the application intelligently.

Q1: Dime.Scheduler on Azure and installation experience

In the first quarter, we will work on the design of the objectives that we laid out in this post. Other than blueprints and technical documents, few artifacts will have been materialized. However, there will be at least one deliverable: the first phase of the transition to the cloud will be completed. The "lift and shift" stage entails that Dime.Scheduler can be run on the same technology stack on an Azure environment.

Furthermore, the installation procedure will be simplified, which is why we will wrap up a first iteration of the all-in-one installer. Gone are the days of fiddling around with configuration files. Clearly, they'll be still there but we will abstract them away with a simple graphical user interface.

Finally, to keep the ball rolling we'll also implement some new features. Expect to see improvements to the planning board and new export capabilities.

Q2: Connectors

After the design has been approved, it's time to migrate Dime.Scheduler to the .NET Core platform. It is imperative that we keep up to date with the latest changes in the industry. Microsoft has invested heavily in (ASP).NET Core and urges everybody to adopt the new framework(s). It is also a matter of avoiding building up technical debt, so it is in our best interest to keep our code base clean and lean.

This upgrade will be a continuous job for the remainder of the year because it cannot be shipped until it's entirely ready. Most of the work we will do here is none of your concern apart from the occasional modifications to the configuration and installation process. We will keep you in the loop with the (monthly or bi-monthly) release mails and documentation platform.

Next up are the connectors. We hope to publish our connector on AppSource and (early) versions of the stand-alone and Exchange connector some time before summer starts in Europe.

Q3: Appointment Containers

We pick up the work where we left it: with the migration to the .NET Core platform, we should be getting pretty close to a release candidate.

In the meanwhile, time will be spent on the appointment containers and other (automation) features.

Q4: Features, features, features

Towards the end of the year the product will be ready for (ASP).NET Core. A lot of time will be spent on testing and providing a migration track to ensure a smooth transition.

Besides this major milestone we'll be able to invest in new features and automation (for example, route optimization and connecting the route sequence component to the planning board).

Final words

We are pretty excited to get started on everything we wrote in this post. Even though our destination is beset with complex conceptual and technological challenges, we're up to the task. In fact, we wouldn't have it any other way.

If we haven't made it abundantly clear by now, we want to hear from you. We can only make a great planning solution when we receive input from our partners and their customers. Our sales, support and product teams will be happy to answer any of your inquiries. We hope to hear from you soon!