Beginners Implementation Guide

As we’ve stated elsewhere, ServiceDesk does so much that if you attempt to comprehend it instantly, you’re likely to meet with extreme frustration. Of course, for any involved subject, proper learning does not work that way. It’s a step-by-step process, with a student mastering first one element of functionality, then another, so that each builds on another in a gradual process. Plus, as new elements are added in this fashion, there’s already a conceptual framework into which new elements can then be fit for full and proper understanding.

At least that’s how it should work, but in ServiceDesk we’ve had a problem in that all its parts are so interconnected (everything ties together) that it becomes difficult to separate one element from another. Thus, in the past we’ve essentially forced new users into a kind of “sink or swim” predicament, throwing at least most of the system toward them in one fell swoop. We realized this made for a daunting gear-up process, but for a long time we’d simply not yet figured a better way.

Well, finally we did. What we’ve done is to modify the ServiceDesk program code in a manner that makes it accommodate usage of selected parts only. In other words, you’re allowed to set it into any of several “learning” modes. In reaction, it will essentially sever the links between what you’re learning and other elements that you’ve not yet conquered. Thus, it becomes practical for you to use and master limited elements without being forced, simultaneously, to use and master the whole set of features.

The heart of this new system is a simple little window in the Settings form. To access this window, go to the Settings form (Ctrl-F1) and look toward the bottom. There you’ll see a button labeled “Learning Steps.” Click on this button and the LearningSteps window will appear. As you’ll see, at the top there’s a caption reading “Operate in mode requiring only . . . “, then there’s a numbered listing of items describing eight, increasingly advanced levels of functionality (the last being unrestricted, no limitations).

As you’ll note, the system defaults (upon initial ServiceDesk installation) to mode 8 (unrestricted, no limitations). This is so that, as you’re doing your initial orientation in the first four chapters of this manual, you’ll have full access to all the functions and links between, to see how they work, particularly when all interconnected. The notion, however, is that after that general orientation process, you’ll skip ahead to this chapter, follow its instructions for setting-up Learning Mode 1, then immediately begin using it—in actual business operation. Naturally, you’ll continue at that level for some time (perhaps a few days) until you feel perfectly comfortable and proficient with it, then advance to Learning Mode 2, and so on—until you’ve plowed all the way into full-fledged, unrestricted operation.

A big advantage of this approach, by the way, is it allows you to start using the very basics all but immediately, and free of any entanglements with the more advanced systems. Previously, we had clients who delayed implementation for weeks or even months, until they felt they’d mastered an understanding of virtually everything. Other clients would dive right in to real-life implementation, but sometimes without adequate preparation and understanding, only to find themselves confused by various alarm systems complaining that this matter or that was not being adequately addressed. Most eventually made it through, but some foundered.

Now, if you’ll but follow the steps as recommended here, we can all but guarantee it will be comparatively easy. In the following sections, we’ll describe each of the steps, explain what’s involved, and provide hints on navigating your way through.

Learning Mode 1: Callsheet Use and Printing of Invoices

The basic notion for this first mode is that, within even hours of receiving your ServiceDesk package, you’ll begin using the Callsheets to manage your telephone work. Additionally (and assuming you’re not converting from a previous software system), you’ll use them to create the work-order/service-tickets for your technicians to take on the job.

The basic notion is that, at this initial stage, this will be the full extent of your business’s involvement with ServiceDesk. You’ll not be using it to actually manage jobs once they are created. You’ll not yet be using it to manage your schedule and dispatch operations, or inventory control, parts ordering, funds control, sales recording, and so on. All those functions will, for the time-being, continue to be operated via your old methods.

Here is a list of tasks we suggest you go through, checking off each preparatory to beginning this first stage of limited operation:

  1. ‍See that you’ve completed the physical check-off items for ServiceDesk itself, as described in the preceding section, but only through the ninth item there listed;
  2. ‍As suggested in the introduction (and for a broad conceptual understanding), see that you’ve completed a careful reading through Chapter 4 of this manual;
  3. ‍If you’ve purchased the video tutorials, now is the time to watch Lesson # 2 therein;
  4. ‍Read all of Chapter 5 (“Call Management”), and do it especially carefully, since this chapter concerns the very processes you’re about to employ (bear in mind, though, it describes Callsheet functions in conjunction with full-fledged, unrestricted operation; for Learning Mode 1 some functions are adjusted, as described in the following paragraphs);
  5. ‍Finally, go to the Settings form, click on the ‘Learning Steps’ button, and set the system into Learning Mode 1.

With this accomplished, please begin immediately to use ServiceDesk for the purpose of managing your calls (and printing up your service tickets, if applicable). Do it with the very next telephone ring. There’s no need to put it off. Throw pen and pad away (at least so far as used these functions). Type the call’s relevant information (whether constituting a service order or not) into a Callsheet. Then, when the next call comes in, type into a new one, and so on. For each instance where the incoming call does involve a service order, type-in all the relevant order information, then click on the Callsheet’s Job/Sale button to print up a service-ticket for the job.

Operationally, the act of placing ServiceDesk into Learning Mode 1 has the consequence of limiting your choices in the Create Job/Sale form. Normally, the default choice there is to Print the Invoice and simultaneously Create a JobRecord (and, incidentally, to insert an appointment into the ScheduleList). When set to Learning Mode 1, however, ServiceDesk allows you simply to print the invoice, without creating either a JobRecord or ScheduleList entry. Thus, with those two particular records not being created as part of the process, there’s no need for you to worry about managing them from within the ServiceDesk context.

Please note specifically that while you may, at this stage, use the DispatchMap to review a customer’s location while taking their order (using the Callsheet’s ItemLocate feature, see page 44), there will not otherwise be any use for the DispatchMap, because you’ll not yet be creating appointment entries in the ScheduleList. And there will not as yet be any use for the JobsCurrent or JobsArchived forms (because you’re not yet creating JobRecords), or even of the CustomerDbase system (which is based on those records). And the drop-down lists for the Callsheet’s Item(s) Type and Item(s) Make boxes will not yet be operative. In short, your ServiceDesk usage will be limited to precisely what we’ve described, and no more.

Of course, this means you’ll still be using your old systems for all tasks except such call management and printing-up of your service tickets. We realize such a mix of systems may seem awkward, but the only alternatives are to either make no transition at all, or else to do it all at once. Though slightly awkward, we think a transitional period of mixed methodologies will usually be most sensible.

We suggest you continue in Learning Mode 1 for a few days, as long as it takes to feel comfortable in this environment.

There is no need, incidentally, to continue reading in this chapter—until after you’ve practiced for a while in Learning Mode 1, and are in fact ready to move on to the next mode. Please (in other words), delay reading the instructions in regard to each following learning mode until you are in fact ready to move onward to it.

Learning Mode 2: Adding-in Schedule and Dispatch Management

As stated, when you invoke the Job/Sale process from a Callsheet in the context of Learning Mode 1, the system will not (as it otherwise normally would) insert an appointment reference into the ScheduleList for you. The big change in this mode is that now it will do exactly that—meaning that now we’ll expect you to begin using, and successfully managing, the various tools ServiceDesk provides for schedule and dispatch management. To prepare for this stage of operation, we recommend the following:

  1. ‍If you’ve purchased the video tutorials, now is the time to watch Lesson 3 therein;
  2. Now please carefully read all of Chapter 6 (“Schedule and Dispatch Management”). Again, bear in mind that some of the described operations are modified by the limitations of this Learning Mode (as particularly described in following paragraphs), but please try absorb the matters described there, regardless;
  3. ‍Go to the Settings form and assure that the ‘Next Invoice Number’ value is appropriately set (this is necessary now, since the system is going to be using appointment references within the ScheduleList, and each such reference needs to be identified by an invoice number); and
  4. ‍Also in the Settings form, click on the ‘Learning Steps’ button, and set the system into Learning Mode 2.

With this accomplished, continue using the Callsheets just as you did in Learning Mode 1. Only now, when you invoke the Job/Sale process from a Callsheet, you’ll notice that ServiceDesk does something besides merely printing-up a service ticket for you. Assuming you have an appointment reference in the Callsheet’s ‘Date & Time’ box, it will also (as part of that process) insert a corresponding appointment reference into the ScheduleList (though still not creating a JobRecord).

This means that now, after you’ve taken in a few scheduled service orders via your Callsheets and likewise invoked the Job/Sale process from each, you’ll find that your ScheduleList (accessed by pressing F6) suddenly contains a number of appointment entries. And if you press F5 to view your DispatchMap, you’ll see each of the appointments are graphically displayed, in the correct positions. And now, we’ll expect you to manage these (along with others that enter the list), control your dispatching, and so on, via the processes described in Chapter 6.

There are, of course, a few differences from normal, unrestricted operation in this Learning Mode 2. Most significant is that your appointment references (within the ScheduleList and as displayed on the DispatchMap) will not as yet have any within-ServiceDesk JobRecords to reference (because, obviously, you’re not yet creating those). This has consequences such as: (1) If you try to invoke a ShowJob action from the DispatchMap (see page 84), the system will report it cannot find the job (for, in fact, no JobRecords yet exist); (2) The system will refrain from its normal practice of retaining appointment references until PostVisitReports are made in their connection (see page 101); since we’re not yet managing actual JobRecords within ServiceDesk, there’d be no purpose in these; (3) When making new appointments in connection with a job that was previously created from a Callsheet (e.g., the technician was already there on the initial appointment, he ordered a part, it’s come in, you’ve called and rescheduled the customer, and now need to get that second appointment into the ScheduleList), such appointment references will have to be added into the ScheduleList by manual means (see page 95), since as yet we have no JobRecords from which such insertion could be invoked more automatically (ibid); (4) Your various actions within the Schedule and Dispatch system will not have a historical record, since there are as yet no JobRecords for such a history to record to; and ((5) There will still be no CustomerDbase to work with, since again that feature is based on ServiceDesk JobRecords, which do not yet exist.

Operationally, this mode is perhaps slightly more awkward than the first one, because we’re not yet involving ServiceDesk JobRecords within our setup, and yet it’s normally intended for so much interaction to occur between these and the ScheduleList. Even so, we think it will be beneficial for you to operate at this stage for at least a few days, until building at least a reasonable competence therein (the involvement of JobRecords, as occurs in the next Learning Mode, introduces a lot of additional expectations, and that’s why we wanted to keep this mode separate).

Please work each day, while within this mode, to assure that every time an appointment is made (regardless of the context), there’s an appointment reference inserted to the ScheduleList in its regard. Remember that when you’re first taking in a job order via a Callsheet (and invoking its Job/Sale process), ServiceDesk will make this insertion for you. But for subsequent appointments on that job, you’ll have to invoke the insertion manually (typing in each of the fields) from within the ScheduleList form itself, by clicking on its ‘New Item’ button (bear in mind this will be easier in all subsequent stages).

In consequence of fulfilling this duty, you should find that your DispatchMap constantly reflects what’s actually scheduled with all of your customers (make sure that it does, and correct if there are discrepancies). Thus you can use the features described in Chapter 6 to facilitate dispatch and related processes each and every day. And now you can schedule intelligently while taking in new job orders via the Callsheets (using the ItemLocate feature to compare location with other scheduled jobs, the techs they’re assigned to, etc.). And so on.

As in Learning Mode 1, we suggest that at some point in this stage, probably when about midway through, you review the applicable command summaries as provided on the ServiceDesk MainMenu bar. For this Learning Mode 2, click on “Command Summary” then choose “DispatchMap Controls” for one review, and “ScheduleList Controls” for another.

At any rate, when you feel you’ve reasonably mastered (and are practiced in actual usage of) the basic operations involved with Scheduling and Dispatch (excepting, of course, those that cannot yet be done, lacking attached JobRecords), it’s time to move onto Learning Mode 3.

Learning Mode 3: Adding-in JobRecords, and their associated management

Hooray! Finally we’re ready to address the final anchor of ServiceDesk’s foundational triad. Having mastered call-taking operations (which incidentally involve the initiation of jobs) and schedule management (which also obviously involves jobs, though we’ve managed it to date with those jobs existing completely external to ServiceDesk), we’re now going to introduce the underlying context within ServiceDesk by which each and every job is represented specifically as such. To prepare for this stage of operation, please do the following:

  1. ‍If you’ve purchased the video tutorials, now it’s time to watch Lesson 3 therein;
  2. ‍Carefully read all of Section A (“The WorkInProgress System”) within Chapter 7. As always bear in mind that some of the described features may not yet be applicable, because we’re still limiting things in connection with the particular learning stage we’re in;
  3. ‍Go to the Settings form, click on the ‘Learning Steps’ button, and set the system into Learning Mode 3; and
  4. ‍If you’ve not previously done so, we also suggest that while you’re in the Settings form you now turn ‘on’ the feature labeled “Do nightly Archive/Cleanup of files” (from one station only), along with the feature labeled “Send WipAlerts” (also from just one station please).

With this done, you’ll find something rather different occurring (at least as compared to previous Learning Modes) when you invoke the Job/Sale process from any Callsheet on which you’ve written a new service order. Now, in addition to being ready to print-up the service ticket and insert an appointment reference to the ScheduleList for you, the system also defaults to a mode where it’s ready, as a simultaneous part of that one simple Job/Sale event, to create an actual JobRecord (press F7 after invoking the process when now in this mode, and you’ll see that now you’ve got your first, real-life JobRecord now in the system).

It is the JobRecord, of course, that’s the primary instrument in ServiceDesk by which each job is managed, and into which the system records each of the events that occur in connection with a particular the job. Thus it’s a milestone, indeed, to now be at the stage where we’re using these electronic job representations. It opens up all kinds of possibilities.

Those possibilities are primarily discussed, of course, in the section we’ve instructed you to read for this learning stage, and to avoid redundancy we’ll not elaborate too extensively here. Suffice it to say (as, for the most part, you’ll see upon such reading) that now you can do things such as: (1) Inserting secondary (i.e., after the job was created) appointment references to the ScheduleList much more automatically, using procedures that can be initiated from the now-existing JobRecord, including ItemLocate and On-Map scheduling, much as can be done from a Callsheet when initiating a job; (2) Doing a ShowJob action from the DispatchMap; (3) Reviewing the details of a job from within ServiceDesk; (4) Manually recording details of job performance within its History section; (5) Having the system automatically record, within the JobRecord’s History section, various scheduling and dispatch events as they are performed; and (6) Finally, the CustomerDbase system will begin to become operative as you develop an accumulated history/set of JobRecords to form its underlying basis.

Of course, with the system of JobRecords now in play, along with the new benefits there will also be some new operational duties. Foremost among these is that now the system will expect: (1) For every jobbased appointment that’s inserted to the ScheduleList, someone will dutifully make a PostVisitReport in its connection (see page 110); and (2) You must now make sure there is appropriate activity, in connection with each JobRecord, to indicate adequate work is being done to achieve its completion (otherwise, you’ll be hounded by WipAlerts; see page 118). Specifically, since many of the within-ServiceDesk auxiliary and ancillary processes are not yet in play (at this learning stage), it happens that many of the activities that would otherwise record automatically to a JobRecord (such as checking-in ordered parts, for example), will not yet do so. Thus, for this learning stage you may find there’s a greater burden (than there will be later) to manually document (within a job’s History section) various things you do (such as ordering parts, etc.) to work the job toward completion.

Speaking of which, we’ll explain here that operationally ServiceDesk makes just a few internal allowances for this Learning Mode 3. Specifically: (1) Whereas normally it will not retire a JobRecord out of the CurrentJobs file and into the JobsArchived space until after it has been recorded to the SalesJournal (and its “status” marked accordingly), for this learning mode and the next one (i.e., until Learning Mode 5, where we introduce Sales Reporting), the system will “archive out” any JobRecord when it’s simply been set to “Job Completed” status.

This means, incidentally, that operating in this mode there’s another special duty you may sometimes face. Typically, JobRecords will be set into “Job Completed” status in consequence of a query answered (“Is the job done?”) during the PostVisitReport, but sometimes circumstances will conspire otherwise. It may happen, for example, that the technician returns with a possible part order, depending on what the price proves to be after research is done—and the PostVisitReport is made with the matter still hanging, so the query (“Is the job done?”) is answered negatively at such time. When the price is determined, the customer declines to proceed, so now the job needs closed out. In a later stage (after we’ve gone on to Learning Mode 5 and introduced Sales Reporting), the procedure will be to simply make an entry in the JobRecord’s History (indicating that the customer declined), then record its completion to the Sales Journal. But since we’re not yet invoking any Sales-Entry procedure, it will at this stage be necessary (in like or similar circumstances) to make the History entry plus manually change the JobRecord’s status into “Completed” mode (otherwise, again, you’ll eventually be hounded by WipAlerts asking you to either show activity on the job or complete it).

Another internal allowance ServiceDesk makes for this stage is that, when you’re making PostVisitReports, it will refrain from querying you in regard to functions (such as funds collected, parts needing ordered, parts used from stock, etc.) that you’ve not yet implemented. In fact, queries are limited in each Learning Mode to just those that are relevant to the functions that exist at such point. Thus new queries are added, in regard to each such function, as you implement the corresponding Learning Mode in steps yet to come.

Learning Mode 4: all the above, plus Funds Management

From here on out, each new stage should be comparatively simple and straightforward. The reason is because now, rather than a step-by-step adding-in of what are essentially the system’s three interdependent roots, we’ll instead be doing a step-by-step adding-in of what are instead more like branches on the tree, which is obviously a simpler process (though these are also highly interwoven, the addition of a branch is just plain easier).

At any rate, to prepare for this stage (and if you’ve purchased the video tutorials), it’s time now to watch Lesson # 4. That lesson will, in fact, pertain to this and the remainder of the learning modes, but since that lesson in the tutorials is not distinctly divided into corresponding subdivisions, it will only make sense to watch the whole lesson all at once.

Regardless, it’s time at this point to carefully read Section D in Chapter 7 (“Tracking and Depositing Funds”), then go to the Settings form and switch to Learning Mode 4.

Having done as applicable from the above, simply follow the procedures (at least to the extent the present stage allows) as outlined in that manual section. The idea, obviously, is that now you’ll be using the built-in ServiceDesk system to document and manage each item of money that’s taken in by your business (including the making of bank deposits). It’s a terrific system, and you’re almost guaranteed to love it very shortly.

The one limitation, for this stage, is that you’ll not yet be able to use the normally-intended system for reporting on those funds that are received after a job has been completed and recorded to the Sales Journal (i.e., checks received on billed jobs, see page 157). The reason is because the normal method depends on having an AccountsReceivable record, in force, that such items of money can be applied toward—yet such records will not be created until the next learning stage, in conjunction with reporting on completed sales. For such reason, when such items of money come in, during this stage, you’ll need to use the direct, manual method of insertion, as provided in the Funds form (i.e., use its ‘Add Item’ button). This is important, for from now on you’ll want to have all such checks on-record within your FundsJournal for at least the purpose of preparing accurate deposits. There will be no recorded application of the check to a specific job, of course (or to any job’s AccountsReceivable record), but that’s okay, for ServiceDesk has no such records at this point regardless.

Learning Mode 5: all the above, plus Sales Reporting and A/R Management

This step is very self-explanatory. In preparation, please carefully read Section A in Chapter 8 (“Recording Sales, Tabulating, Etc.”), then switch to Learning Mode 5 from the Settings form. Simply follow the procedures described in that manual section, then immediately begin using ServiceDesk as the means for recording your completed sales, creating reports on sales and related items (such as sales tax liability), creating Accounts Receivable records, managing those, and so on.

A potential but small complication is that, depending on how long you remained in Learning Mode 4, there may be jobs on which you’ve collected money, yet there’s no record of it in the FundsJournal (for the simple reason such money was collected before you moved into Learning Mode 4 and began recording funds received). If this is the case, as you go to record a completed sale to the Sales Journal via the SalesEnter form, you’ll find that the system fails to identify those previously collected funds. In consequence, if doing a paid sale, you’ll need to respond to the warning ServiceDesk provides (indicating that funds have not been found to satisfy a paid sale) by indicating you want to proceed with the entry regardless (an option that’s provided, though it requires use of your custom password). If, on the other hand, you’re recording a billed sale on which partial payment was collected (and again, that payment is not in the system because it was made before you began recording such matters), you’ll need to manually enter the partial payment into the A/RCreation form (again, an option that’s provided, password-required). Though a small inconvenience, this transitional stage will pass very rapidly.

A primary thing to remember at this stage is that now the system expects that each JobRecord will eventually be recorded, as a completed sale (even if for a sale amount of –0-), via the SalesEnter form. And it expects you to manage your AccountsReceivable (which result in part from that process), keeping on top of them by sending out statement or dunning letters when past due, and so on.

One of the great beauties, as you achieve this stage of ServiceDesk implementation, is that now you’ve achieved great security for most of your various processes. No longer can you lose a job (either between the cracks or via a wily technician claiming it as his own), or even unduly neglect it, without knowing about it. Each must be recorded, as a sale of some kind at least, or else alarms are triggered. And no longer can you inadvertently give a sale credit for having been paid (absent password-protected overrides, at least), unless you’ve got entries in your FundsJournal reflecting such payment. And no longer can you charge yourself with having collected such funds, unless you also show they properly reached deposit or other proper disbursement—or again alarms are raised. You’ve come a long way baby!

Learning Mode 6: all the above, plus the Non-Stock Parts Ordering and the UIS system

There’s not much to explain here aside from what’s in the relevant sections of the manual (Section B in Chapter 1, “Managing Special-Order Parts”, and Section B in Chapter 10, “The Unit-Info System”): please read both carefully in preparation for this step, and follow the procedures they describe. Of course, don’t forget also to switch into Learning Mode 6 from the Settings form also.

The functionality that’s introduced here is, primarily, just a great convenience. The system makes the burden of managing your special-order parts process far lighter (automating and facilitating each step), and integrates it with all other processes. Thus, there will now be a query during each PostVisitReport concerning whether parts need ordered. And there will be opportunity to create and/or attach UIS sheets to the job in question, etc. And, when actually ordering, checking in parts, and so on, relevant entries will be made to the connected JobRecord’s History (documenting these processes right on its face), and so on.

Another benefit, that’s connected with setting up the UIS system, is added functionality in the Callsheets. Now, with the UIS system setup, you can have handy drop-down boxes in the ‘Item(s) Type’ and Item(s) Make’ boxes of the Callsheet, offering for auto-insertion the types of entries you’ll typically be making to these boxes. Not a huge thing, but it’s rather handy.

Learning Mode 7: all the above, plus Inventory Control [i.e., stocking parts]

In preparation for this step, please carefully read Section C in Chapter 7 “Managing Stocked-Parts Inventory”, and of course switch to Learning Mode 7 in the Settings form. Then, of course, you’ve got to do all the setting up for your inventory system that described in that section. That in itself is not easy, and indeed involves probably more work than the prep for any other learning stage (though it’s not ServiceDesk work per se). That’s why we’ve left this as the last major learning mode. Other than that, there’s nothing special here that needs to be said about it.

Except, we should say, when you do finally get around to it, there are enormous rewards in getting this system setup and operating. Now, in addition to all the other kinds of security that ServiceDesk offers, you’ll also have security in knowing you are never losing items of inventory without knowing about it, in knowing you’ve got the intended items at intended locations, in the quantities intended, and that you know exactly what you have and where. Security in knowing what needs reordered, what needs restocked and where. Security in knowing what your usage has been for each item, costs to obtain, etc. It is, in short, all very wonderful, and of course there’s also enormous convenience in terms of the processes (usage documented as part of PostVisitReports, easy restock, reordering, etc.). You’ll love it!

Learning Mode 8: Full Implementation Unrestricted, no limitations

Congratulations. You’ve now completed all the intermediate learning stages. It’s time to reward yourself by switching into Mode 8 from the Settings form. Notice, this is not a developmental learning mode. You are now a graduate. Yahoo! Horray! Can life get any better than this?

Actually, there is still learning to do.

In particular (and if you’ve purchased the video tutorials) you should now budget some time to watch Lesson # 6 (dealing with the various auxiliary functions) and # 7 (which goes over the various utilities that come with the system). And regardless, you should read the corresponding Manual chapters, 9 and 10.

But at least at this point all the primary operating features have been put into play. What’s left are add-ons, auxiliary and ancillary features that may enhance, improve and help your work, but are not essentially integral with fundamental processes.

Probably the most important of these is the SourceOfJobs survey (Section G Chapter 10), but it’s by no means the only one. To learn what still may be added to your repertoire, it’s a good idea now to peruse this manual’s Table of Contents (particularly in regard to Chapters 9 and 10). Better yet, why don’t you simply read Page 264 those two chapters in their entirety (and implement desired features as you encounter their description). Then, to further deepen your understanding and skills, look over Section 4 in the Appendix (i.e., the one on “Technical Information”). The title may sound scary, but the descriptions are as down-to-earth as circumstances allow, ant there’s a ton of information there, much of it very useful.

Aside from this, we suggest you review sections in the manual on an as-needed or as-wanted basis. And please, let us know how this step-by-step implementation and learning process has worked for you. We’re anxious to know.