When Should You Purchase The NAV License?

Microsoft Partners often postpone the actual purchase of the customer’s NAV license until the project is fairly close to go-live. In the meanwhile, they do the development and the testing on-site (or off-site) using their own partner license.

I’ve heard arguments (or better: excuses) to engage in this practice, and I have a very strong opinion on this. So, when is the right moment to actually purchase the NAV license for your customer?

Well, regardless of the fact that 1) you are contractually obliged to purchase the license for your customer at the first moment they get in touch with the solution (which is fairly early in the project), and the fact that 2) you are violating your licensing agreement with Microsoft if you deploy your partner license on third party’s infrastructure, there is 3) a fairly compelling technical reason why you might never want to even try doing any project work involving customer with your partner license.

The first two reasons above are bound by pure legal gobbledygook and I don’t even want to enter an argument about whether it is justified or not. It’s just the way it is—comply or die.

However, one compelling reason why you are far better off purchasing the new customer license immediately the project commences, is testing.

Let’s say you are testing all functionality on your partner’s license and you find everything to be working exactly as expected. The moment you deploy the solution into production with the partner’s license, it might just go dead—suddenly you might find out that a lot of functions that used to work, now just don’t, and the system might keep bugging you for quite a while with needed granules that your license simply doesn’t come packed with.

Even though sometimes you might be feeling lucky, and hoping that Microsoft will turn a blind eye to your malpractice, you should never ever try deploying your partner’s license into production. If you do that, the migration to customer’s license might just turn into your worst nightmare (and that’s even before Microsoft finds out what you are doing there).

How can it happen that a needed granule slips under your radar? Well—fairly easily, take a look at just this example. In NAV, if a table belongs to a granule, and a piece of code tries reading from that table, and you don’t have the needed granule in your license, you are going to get an error only if there is data in the table. If the table is empty, and the code being executed doesn’t insert any data there, NAV just keeps executing the code. However, if there is at least one record in that table, NAV is going to complain (and your end-users are guaranteed to do even more so). If you ask how the data could have entered such tables—well, the answer is pretty obvious: exactly because the customer had a license which allowed the to do so, by accident this just might have happened. And it just did. Trying to clean all those nasty little unlicensed accidental data entries can turn into an infinite loop of trial and error, because sometimes it is difficult to test everything once you are under pressure of having to run a production system with a misconfigured license.

The latest the customer’s license should be configured and ready is acceptance testing—if by then you didn’t yet purchase or fully configure the license, then just stop the testing, because whatever you do pretending you do the acceptance testing will not be the acceptance test, because the critical part rendering the test results valid is the license, and it’s not being tested at all. If there is a serious licensing problem that might halt production, it should pop-up during acceptance testing, because this is the moment you validate everything.

More than a couple of times I’ve heard complaints that sometimes it’s difficult to test new functionality with customer’s license because you need to test the functionality first, and after it has been tested you order any extra objects missing from the license. Well, yes, if you skip an important part of the development, which is design. If you don’t do design, then yes, by all means, it’s heck of a job to test any functionality, with or without partners, or customer’s or whoever’s license. If you happen to do design, then you might order the needed objects ahead of time, before the coding starts, and since it doesn’t take more than a day or two to get the license, which should be enough because the license file might arrive just in time as you deliver the new functionality.

Another nice trick you might pull is pre-fill the license with object ranges if you expect adding objects later. It will increase your cost (as a partner), because you bear the costs of the objects before your customer actually needs them, but then you can easily develop new functionality without having to worry much about licensing issues in production—simply invoice the objects to the customer the moment you deploy them. This is going to cost you some probably insignificant money, but will in turn make your customer happy (they will not be aware that they are happy, though, but still—you know they are).

*Note: any resemblance to real people, living or dead, is purely coincidental.


Vjeko has been writing code for living since 1995, and he has shared his knowledge and experience in presentations, articles, blogs, and elsewhere since 2002. Hopelessly curious, passionate about technology, avid language learner no matter human or computer.

This Post Has 5 Comments

  1. Luc van Vugt

    You did again hit the nail on it’s head, Vjekoslav! Thanx.

  2. Nikolas

    Great article.. will definitely share..

  3. Dhan Raj Bansal

    Nice explanation. Keep it up.

Leave a Reply