8 reasons to switch to Kentico MVC

Written by Ilesh Mistry
September 14th 2018

11 mins read

Kentico are focusing their attentions towards MVC rather than the Portal Engine approach. Whenever they decide to build any new features or they decide on some functionality, Kentico will look at it in the MVC model first. If they feel it would be something they could add easily to the portal engine model, then they may consider adding it.

MicrophoneKentico announced during the last roadshow, that it would like the Kentico partners to go down the MVC route rather than the ASP Web Forms route. Here are some of the main reasons for their switch in focus:

  • As Kentico create more and more features, it is difficult to maintain two completely different development models
  • ASP Web Forms are less used these days compared to MVC
  • ASP Web Forms are an old technology model
  • Developers prefer the MVC model
  • MVC model allows Kentico to push towards the latest standards and requirements within the fast-moving CMS technology industry
  • Kentico Partners always find it hard to recruit new developers, but it’s even harder to recruit for ASP Web Forms. It is easier to recruit for MVC developers
  • With the MVC model, Kentico can reduce and deprecate features which would no longer be required
  • Kentico can focus on making their CMS lean and lightweight via the MVC model
  • Upgrades to Kentico are easier to make in MVC compared to the Portal Engine route
  • Hotfix updates are simpler to apply
  • Other major CMSs are either already down this route or are heading that way, so it’s important for Kentico to stay ahead
  • Providing better MVC support in Kentico grows the developer community where different front-end technologies can be included naturally - rather than having to work around ASP Web Forms
  • Under the MVC model, Kentico will be more attractive to developers who may not consider Kentico as a development platform to showcase their skills.

With this mind, here are my top 8 reasons to start developing with Kentico MVC:

1. Better partner developer recruitment

HandshakingHands up, the people who are reading this are involved in recruitment in some way?

Whether you’re looking for a new team member or your next exciting role, you will know it’s tough, dog eat dog world out there. To get ASP Web Forms developers has become increasingly difficult as less and less .Net developers are skilled in it – and fewer actively looking to work with the model.

On the other side, you have the MVC skill. Remember ASP.NET MVC is not a new skill, it’s been around for years and years, so there are no shortage of experienced developers to strengthen your team with. Another aspect to this is that new developers who are choosing .Net technology stacks will only be learning and developing in MVC, knowing that ASP Web Forms will be slowly phased out by Microsoft.

This makes it essential during recruitment and although finding the right candidates are never easy, it’s more focused and recognised skill within the developer market to help recruitment easier.

2. The HTML mark-up world is your oyster

World map with money spread out on it
Creating Kentico MVC sites allows developers to work with a blank canvas. You can put whatever you like within the layout view (within reason) without having the mark-up determined by the CMS or framework.

This is unlike the ASP Web Forms route, where a lot of mark-up was defined for you. You would also have to deal with the one Form tag that controls the whole site and what you do within it. Not to mention the massive block of viewstate rendered onto your page during runtime.

While the Portal Engine did have a lot of perks, this was not one of them. The ability to not manage your HTML Head and Body sections freely can feel really restrictive to your developers, prohibiting what you can do and forcing your team to follow set rules.

Name a developer these days that likes following rules and being dictated to?

With Kentico MVC, the developers have the freedom to create what they want and lay elements out how they want and improve site speed.

Don’t get me wrong, that doesn’t mean your team can go nuts - they would still need to follow best practice guidelines!

3. With extreme flexibility comes increases in credibility

Colourful children's springs
During website development you would run your sites against various site checking tools for site speed, performance, validation, accessibility and even SEO. As you will know, it’s tricky to build the perfect site that gives you 100% within all these tools. All of them have different benchmarks and standards.

With ASP Web Forms, due to certain elements and mark-up determined by the CMS, it’s a huge challenge to get anywhere near the 100% mark in all the tools. This is purely because specific CMS mark-up can’t be changed without custom development.

With Kentico MVC you have the freedom to get rid of the bloat and create the mark-up how you want. So, when running your tools, you will have a far greater chance in resolving any issues identified and really push for that 100% mark.

Kentico MVC will provide you the platform in which you can improve your scores in:

  • SEO - with flexible metadata and schema mark-up
  • Accessibility - with greater control of what is being rendered and how
  • Site speed - only the mark-up and specifics you specify, and call will be shown to the user
  • HTML validation - cleaner and standardised mark-up can be used

4. Calling all the front-end kings and queens

King and queen on a chess board
The ability to do what you like with the mark-up in MVC opens an endless number of front-end technology stack paths you could go down.

I’m not saying these paths are closed off with the Portal Engine route, but it’s more difficult, it has more restrictions and may involve custom development to make them work.

With Kentico MVC, you can go for simple small HTML and CSS sites and more complex ones with specific grid layouts.

You can now use the latest and greatest JavaScript frameworks out there like Vue.js, React.js etc… without restrictions.

You also have the ability to create bog standard websites (simple or complex), create single page applications or create a hybrid of JavaScript dynamic components within pages. All of which are possible with greater ease when implementing with Kentico MVC.

5. Lightning fast deployments

Time lapsed cars passing through the road during night time
Kentico MVC allows you to split your Visual Studio solutions and using Web Applications. Therefore, you would have one for the MVC app and one for the admin app.

There are many benefits in doing this, including the ability to setup extra security to your admin app. Along with this you also have the ability deploy each app separately. As the MVC solution is a lot smaller and packaged you can build and deploy this faster than you could for portal engine solutions.

6. Increase your Kentico superpowers

Kids in Spiderman and Captain America costumes
With Kentico MVC you’re basically building most of your controls, reusable elements, pages etc... from scratch with Kentico API. This will provide you an opportunity to excel your Kentico API skills as it provides you most of the features and functionality you would have expected while working on the portal side.

It will give your developers greater understanding of what they should be using to retrieve content and build features.

7. Split personality

A mans shoes on two different canvases
One of the biggest reasons for going down the Kentico MVC route is that it provides a mechanism via separation of concern (SoC).

By dividing the application Model (Business), View (User Interface) and Controller (Processing data to view), it allows for each to have their own duties on what they should be doing and what they are responsible for.

This means sections that can be reused are individually developed and updated independently and the concerns are separated.

8. Testing testing testing!

Lots of coloured code on a computer screen
Kentico MVC allows you to write better tested code. With this development model you can write code using the Test-driven development (TDD) model. Using this approach will allow you to have smaller development lifecycles by your team creating smaller test cases, improving the software to pass new tests.

This was not as easy to do via the Portal Engine route without lots of customisation, or if the development was focused on less Kentico specific parts of the build and more towards third party integrations.

There is no excuses for untested code now!

Summing up

That was my top 8 reasons to switch from the Kentico Portal Engine development model over to the Kentico MVC development model. While there are certainly still merits to following a web forms model, the opportunity afforded by Kentico MVC is too good to pass up. Your team will be happier, your deployments will be smoother and ultimately your product will be stronger working under an MVC model.

If you need to look at some of the steps involved in transitioning to Kentico MVC, have a read of this blog series to help you on Transitioning to Kentico MVC.

Still not sure if Kentico MVC is right for you? Get in touch to speak to one of our Kentico specialists.