Thursday, January 31, 2013 by Per Ploug

Umbraco 6 is out!, and it brings a ton of new, and exciting features to Umbraco, like new API’s, datalayer and MVC.

Read more about Umbraco 6 here 

UPDATE: Over half of the seats are now sold in under 24 hours.

As a special event for Umbraco Level 2 certified developers, we now offer a 1 day upgrade course, at a very tempting price: € 499.

Order a spot on the course

For this first class, it will exclusively take place in Aarhus, the city of smiles, but also the city of Umbraco Partners, so a natural place to start these new courses.

In short, this one-day class will go through:

  • The grand overview of all the new terms and features in Umbraco 6 and MVC
  • How you update an existing webforms-based site to MVC
  • Hands-on exercises with the new Media and Content APIs
  • Templating in Razor views
  • Strongly typed views ← ?  
  • Working with forms in MVC
  • Building custom controllers
  • Hijacking Routes and building your own urls

Read more about the corse on the course page here, and sign-up for the course right here.

Thursday, January 31, 2013 by Sebastiaan Janssen

8100154382_5146c 7b 407Well, well, well, what have we got here? Is that a shiny final release of Umbraco 6 - The future of Umbraco? Why yes, yes it is!

After nearly a 1000 testers on the beta and release candidate, v6 is now ready for prime time! 

In the past 10 days, we've fixed bugs we found internally after doing dozens of clean installs and upgrades. We also fixed a few dozen bugs that YOU, the community have found and we can't thank you enough for all the bug reports, they have helped us a lot in making this a high quality release.

We've also had a lot of feedback on the upgrade process, especially the database step that was scary because it was using the wording of when you install Umbraco from scratch. So now we properly indicate that we are upgrading, doing some extra tests to determine which database upgrades are necessary and will show you errors that are easy to digest if something does go wrong. 

As a reminder of what's so great about v6:

  •  A brand new API for Content and Media - Read Niels' blog post about the ContentService
  • Upgrade from MVC 3 to MVC 4 and support for Partial View Macros
  • You can now use PetaPoco and the database migrations framework that we added onto it
  • Support for nested media types in the backoffice
  • Ability to restrict the document types that you can create under the Content root node
  • 99% backwards compatible with Umbraco 4

For all the details, check out the download page and then get with the future and start installing!

Monday, January 28, 2013 by Niels Hartvig


Umbraco may have been my brainchild, but it would never have gotten this far if it weren’t for the many people who’ve helped along the way. From my wife who told me to “just do it or stop nagging about the other tools”, to Thomas Madsen-Mygdal, Kasper Bumbech and Anders Pollas with whom I sparred in the very early days or the many, many other developers, designers and editors who through code, feedback, packages, community help and testing have helped make Umbraco what it is today.

That’s the story we all love and also use in sales pitches. It’s the product of a big community with thousands of contributors. More than 100.000(!) people visit Our Umbraco every month, we’re beyond 500 add-ons and the amount of pull requests for the core are at an all time high.

Umbraco is the product of all of us, not just me or the employees in the HQ. The idea that a tiny company of less than a dozen people could have such a huge impact on the world of CMS is flattering, but unreal.

There’s so much to love about a project like Umbraco, but of course there’s no such thing as a free lunch. When you love to use Umbraco to win a project because you’re standing on the shoulders of a big community, remember that you’re that community too. That the quality of Umbraco can never be greater than the amount of investment in that community.

When a new version of Umbraco is released, it shouldn’t be just the product of a handful of developers in a tiny Danish company. It should be the product of all of us. There’s so much potential if all of us could find just an hour a year to help with testing, fixing bugs and sparring on new features.

When we release a beta of Umbraco, it’s a great chance to help. Not just installing it - but by trying some of the stuff you’d do when the release comes out. Like using some of your favorite packages, testing your own code, running it on your usual host and maybe even trying to upgrade an existing site. Helping catching bugs during the beta phase is what leads to a better release and less frustration when it really hurts. Last year we launched a contribute section to help you get started.

The quality of the core is the responsibility of all of us - from the employees in the HQ, to the smallest of agencies using it for their clients.

So don’t think what the HQ can do for you, but what you can do for your CMS.

Friday, January 25, 2013 by Niels Hartvig


Maybe you’ve heard about Umbraco CodeGarden, maybe not. Maybe you’ve heard about it, but yet don’t really know what it’s about.

CodeGarden is our annual Conference about Umbraco and takes place in Copenhagen, Denmark on June 12th - 14th 2013. But in short you could also describe CodeGarden like this: “If you haven’t been to CodeGarden you haven’t experienced Umbraco”.

I believe that Umbraco is great because it isn’t just a piece of software. From the very beginning the community has been a big part of what it was and it’s been an increasing motivation for me to keep believing in the project.

Umbraco is fundamentally about inspiring and empowering people to build great sites. The software is a big part of this, but the inspiration comes from people that through our forums, their blog posts and by sharing open source packages, opens a lot of peoples eyes and help them realize that they’re capable of much more than they’d think.

You’ve probably used our community site “Our Umbraco” a few times - maybe even without knowing it. If you’ve ever installed a package, that’s Our Umbraco who did that for you. If you looked up documentation, that’s Our Umbraco too. So is the roadmap. And of course, if you’ve ever needed a question about Umbraco answered, it was probably powered by Our too. You could easily say that without “Our Umbraco”, there wouldn’t be “Umbraco”. That’s where you’ll find the very soul and vision of Umbraco - what’s sets us apart in a very crowded marketplace.


Umbraco CodeGarden is Our Umbraco - but in real life. It’s where you really understand what Umbraco is all about. You may have felt like you’ve already been there - you could have seen all the sessions on video, browsed through all the beautiful photography taken by Douglas Robar throughout the event and heard so much about the parties and related events.

But like music is great on an iPod, its only experienced and truly felt at a concert. I wholeheartedly recommend that you come to the Umbraco Festival that CodeGarden is. It’s fantastic.

As we’ve already sold more than 30% of the 400 tickets available, don’t hold your breath. Make sure you order your ticket today and experience Umbraco in real life.

And, yes. A website with all the details about CodeGarden ‘13 is coming up very soon!

Wednesday, January 23, 2013 by Niels Hartvig

We’ve succesfully moved Our Umbraco and the issue Tracker to new servers on Azure!

The last couple of days the Our Umbraco site, the issue tracker and also this site have had a lot of downtime, which has been caused by a series of chained events at the virtualisation environment at our ISP. The good folks there have worked almost around the clock for the past three days, but unfortunately it keeps misbehaving.

We’re now in the process of moving the Our Umbraco site and the Issue tracker and hopefully, this will be finished by the end of today. In the meantime, both sites will be unavailable.

We know it sucks and the timing couldn’t be worse with the Umbraco 6.0 RC just released. We’re doing everything we can to get them up fast so you can focus on building great sites and we can focus on improving the current tools – not the infrastructure.

Tuesday, January 22, 2013 by Niels Hartvig

The website and the source code used in this tutorial is available on GitHub.

In this little tutorial, I’ll show you how the new APIs in Umbraco 6 works, by importing a CSV file with products into Umbraco nodes.

For a start, I’ve downloaded Umbraco 6 (currently the RC) and installed the Basic starter kit with the “Sweet As” skin. That gives me a nice baseline for a simple site and also confirms that Umbraco 6 is compatible with most of the existing packages.

The products that I want to import, comes from our own ERP in the HQ. We use a SaaS product called E-conomic (which is awesome, btw) and it’s easy to export our products into an Excel/csv file. For simplicity, I’ve kept it to a very simple model where each product has a Product Id, a Name, a Group and a price.

So to prepare for the import, I’ve made three Document Types:

  • A “Store” document type, which is basically just a container for the products
  • A “Product Group” that lives beneath the store. It has a single property which is the e-conomic (our ERP) GroupId. As we only had seven product groups, I’ve just created them manually.
  • A “Product” that is a child of “Product Group”. To match my exported data it has a Product Id, a Name and a Price. The nice thing about Umbraco is that I can always enrich the boring ERP product data with Umbraco properties such as photos and Rich text descriptions (including embedded YouTube videos to show off the product).

Let’s get started

As I won’t go into details about parsing CSV files (you can look at the full source for that), the code shown in this tutorial is the simplified methods that takes a Name, Product Id, Price and a Product Group and creates it as a node. But as I want to be able to upload a CSV file, I’ll add a simple .NET UserControl to the Dashboard inside Umbraco which contains a File Control and a button. It’ll look something like this:

Screen Shot 2013-01-22 at 12.10.30 PM

If you’ve never played with customizing the Umbraco Dashboard, it’s as easy as editing the /Config/Dashboard.config file. In that file you can add tabs to sections, place User Controls inside the tabs and even add permissions to what type of users can see what tabs. The details, however is a different story – this tutorial are supposed to be about the new API!

Meet ContentService

The new API consists of a number of services which is your “gateway” to Umbraco data. In this tutorial we’ll look at the ContentService which – as you may have guessed – is our “gateway” to interact with content in Umbraco.

When you’re in a User Control or a Template, accessing the ContentService is easy and we’ll get to that in a minute. But before we show you the easiest way, it’s good to know that there are various ways to get to the ContentService. Most of all it depends on whether you’re already in a context of an Umbraco page (technically in an UmbracoContext - for instance in a Template or a view) or if you’re in a Console App (yes, that works!). No matter where you are you can always get to the ContentService via ApplicationContext.Current.Services.ContentService. The ApplicationContext as well as the various Services lives in the Umbraco.Core namespace and is part of the Umbraco.Core.dll. The UmbracoContext and UmbracoUserControl is found in the Umbraco.Web namespace which is a part of the “umbraco.dll” assembly (and that is the name – not Umbraco.Web as that would break backwards compatibility with v4).

So to get started, you’ll need to make a reference to “umbraco.dll” in your Visual Studio project. When you use the ContentService through a User Control, it’s also a good idea to make a reference to “Umbraco.Core.dll”. This allows you to make your User Control inherit from “Umbraco.Web.UmbracoUserControl” instead of the normal “System.Web.UI.UserControl” and gives you super easy access to local Umbraco data as well as the ContentService.

In this example I am using an UmbracoUserControl, but be aware that all the examples could also work in a webservice, a console app or even a Windows Service as long as you can get hold of a valid ApplicationContext.

Ok, enough boring theory – let’s import some products

As you may remember, the original purpose of this tutorial was to show you how simple it is to import our ERP product data as Umbraco Content items (nodes). Now that we’ve learned about the ContentService, UmbracoUserControl and our product Document Type, it’s really easy to creating content items:

private void ImportProduct(int productId, string name, int productGroup, int price)
        // Get the Umbraco Content Service
        var contentService = Services.ContentService;
        var product = contentService.CreateContent(
            name, // the name of the product
            1000, // the parent id should be the id of the group node 
            "product", // the alias of the product Document Type

        // We need to update properties (product id, original name and the price)
        product.SetValue("productId", productId);
        product.SetValue("originalName", name);
        product.SetValue("priceDKK", price);

        // finally we need to save and publish it (which also saves the product!) - that's done via the Content Service

Because we’re in an UmbracoUserControl, we can access the ContentService via a local variable called “Services”. The ContentService has a handy method to create content called “CreateContent” which takes 4 parameters:

  • Name of the new Content item being created
  • The parent id of the new Content item
  • The alias of the document type
  • The id of the user creating the content

The CreateContent method returns a Content item (an IContent) which also allows us to easily edit custom properties via the SetValue method that simply takes the alias of your custom property and a value (Object).

Once we’ve populated our content item, it’s time to Save and maybe also Publish it. It’s as simple as passing our Content object (product) to the SaveAndPublish method of our ContentService.

If you’re used to the old APIs, then you know that this wasn’t needed as data was saved the moment you assigned values to the properties. This caused a lot of database queries and really not considered good practice. With the new API, it’s not until you pass the Content item to the ContentService that a database query is made within a single transaction. With the old API the code above would generate at least five queries but maybe even more if the cache wasn’t up to date.

In the old API you also had to call two different publish methods – one that prepared the document for publish and one that refreshed the cache. With the ContentService, all you need to do is call the SaveAndPublish() method and you’re in business.

The Visual Studio sample project contains a more thorough example where I also update existing Content items and use the fabulous uQuery to look for data.

More to come

In this little tutorial we’ve shown you the first glimpse of what the ContentService can do for you and I’ve deliberately tried to keep it very simple. But the ContentService is more than just simple save and publish - it also support transactional bulk saves as well as bulk publishes. I’ll show you how we can easily refactor the code to support this in a coming tutorial.

Is there other examples or things you’d like to see covered? Let me know in the comments!

Monday, January 21, 2013 by Niels Hartvig

Gentle(wo)men start your engines - Umbraco 6 RC has landed!

After more than 500 downloads and loads of feedback of the beta, we’ve worked hard on getting the last issues fixed and as the baby passed all the items on the release checklist this morning, we’re proud to mark it the Release Candidate, which is fancy lingo for “we think it’s ready and if you don’t prove us wrong really fast, this will be the release”.

In other words - Umbraco 6 is here and real.

But what is Umbraco 6 - 159 great reasons?

Umbraco 6 is everything you loved about Umbraco 4, but with a whole new - and super fast - data layer as well as a new Public API. If this sounds very technical, it simply means that Umbraco is now much faster and more stable in the way it fetches and stores your content and that developers have a much nicer way to interact with Umbraco that follow best development practices.

Umbraco 6 also brings true MVC support (as well as continuous Webforms support), native Razor support and a lot of bug fixes and polish. Like support for master Media types, filtering of what Document Types can be allowed in the root of your site and a bunch of new razor templates to make you work faster. All in all, Umbraco 6 is the product of 159 work items.

But I know and love Umbraco 4 - do I have to learn everything again?

No. Umbraco 6 is 99% compatible with Umbraco 4 and you can work the exact same way that you’re used to and use (most of) the packages you can’t live without. The core team have even made sure that legacy code and packages will be automatically enhanced as well, as usage of the old API will automatically be re-wired to the new APIs behind the scenes.

So while Umbraco 6 brings you true MVC support, native Razor support and a whole new shiny API, if what you love is your XSLT, your webforms and the weird API that I originally made, you can keep doing it in Umbraco 6. But of course we’ll strongly recommend learning the new free toys right in front of you. We’ll even relaunch Umbraco.TV in February with loads of new content to help you get up to speed.

But why are you even reading this, when you can play with Umbraco 6 instead. Go download now!

Wednesday, January 16, 2013 by Sebastiaan Janssen

We're big fans of JetBrains' TeamCity product here at the HQ and use it to produce our nightly builds, all of the Contour and Courier builds. We're also using it to deploy our upcoming Concorde portal and the Our Umbraco sandbox site (and the live site in the future).

In the past few months we've worked hard to bring more quality into the core of Umbraco and our other products and have introduced unit tests using the NUnit framework. This is working out great and whenever we see new tests failing either locally or on TeamCity, we know that we messed something up without realizing it. Cool, that really helps making our releases of higher quality.


There's one problem however, that I noticed recently: deploys and nightlies appeared online while the tests for them were actually failing. So anybody downloading those releases got a version with known bugs, not good.

When I looked into this, the cause was evident: TeamCity runs NUnit, NUnit reports that it did it's job and found x failing tests and y succeeding test. Nothing failed in NUnit itself, so it reports back: "I did my job succesfully, nothing to see here". In other words: The errorlevel was 0.

Thing is.. TeamCity can cancel the next steps if the errorlevel is higher than 0, but NUnit tells TeamCity: "I just did my job there were no exceptions in my code. There might have been in the code I was testing, but I functioned just fine. Errorlevel: 0".

Apparently this issue has been known for a while and JetBrains don't currently have plans to make modifications.


I had a terribly difficult time finding a workaround, but I finally did.. and it's really pretty easy!

I've set up a TestProject on BitBucket and if you look in the tools folder I added the most minimal set of files needed to run NUnit. 

Update: As Eugene points out in the comments another workaround is also possible, that will give you the test output while it is running. The workaround below will only give the output after the tests are done.

To make this happen, copy the TeamCity NUnit addin dlls into your NUnit folder and then run the NUnit console. It's basically the same what I'm doing below but with the added benefit of getting real-time test results. 

See the Teamcity2.proj file in the TestProject for an example as to how to configure this.

In TeamCity I can then define a build step of type Command Line and have it run the tests, outputting a results XML file, in the case of the testproject the command looks like this:

tools\NUnit\nunit-console.exe TestProject.Tests\bin\Debug\TestProject.Tests.dll /result=TestProject.Tests\NUnitTestResults.xml


This results in a proper Errorlevel. 0 if there were no tests failing, something else if there are tests failing. Result: the next build step is not performed, awesome!

But.. TeamCity gives you a super handy overview of tests results and allows you to drill down into them when something fails, this was now missing, there's just a message "process exited with code 1". Not very helpful.

Then, I discovered: Additional Build Features. You can find this option in your TeamCity project configuration on config step 3, under the build steps. One of the build features you can add is XML report processing. And that's where our NUnitTestResults.xml file comes in.

Conveniently, there is a report type called NUnit and all you have to do next is tell the report processor where to find it, in the monitoring rules, in my case I had to enter: TestProject.Tests\NUnitTestResults.xml


Et voliá! The build result is once again complete, including the failing unit tests, and the next step will be cancelled because this step is correctly reporting an errorlevel that is not 0.


I hope this helps some people out there who are as frustrated about this as I was! 

In the TestProject, I also have a TeamCity.proj file that uses the MSBuild Community tasks library to run NUnit and that produces the exact same result. So you don't have to do this using a command line, you can incorporate the same thing in an MSBuild file if you want.

Friday, January 11, 2013 by Sebastiaan Janssen

It's a new year, high time for a new Umbraco version number!

Short version: Umbraco 6.0.0 beta is out, it's awesome for developers, go download it!

What to expect

v6 has very strong ties to v4, in fact we've been building 6 while v4 was under development and have very regularly synced the changes from 4 into 6. So everything will look and feel the same, but a lot of things have changed under the covers.

This makes v6 a very developer-centric version, here's what you get:

  • Completely rewritten API's for working with Content and Media in your custom code and packages (some documentation will come later, but make sure to explore the ApplicationContext.Current.Services.ContentService and ApplicationContext.Current.Services.MediaService)
  • The API makes use of PetaPoco a tiny object relational mapper. We've also built a layer on top of that so that all the syntax difference between SQL, SQL CE and MySQL have been abstracted away, so no more need to write three different queries
  • With the above change it was also fairly easy to write a little migration framework that can take care of database updates, again: no more need to have upgrade scripts per database type
    • PetaPoco and the migrations framework are public, so you can use them in your custom code as well!
  • We now support Partial View macro's if you're using MVC in Umbraco, these macro's supercede Razor macro's (although, don't worry, you can still use them and you will be able to use them for a long time to come!)

These are the most important and big new changes to v6, check out all the links on the release page as well.

Breaking changes

There are some breaking changes in this release, the most important one is the way that properties are saved has changed. Previously, we had this insane thing going on where when you did this:

doc.getProperty("pageTitle").Value = "Hello World";
doc.getProperty("dogName").Value = "Lassie";
doc.getProperty("iLove").Value = "Umbraco";

every line of this code would update the document, so 3 updates to the database where you only really want one.

In v6, you can finally just update all your properties first and then save them all in one go. But it means that if you want them saved, you have to explicitly call the save function:


And now you've saved the document with the 3 changes above in one nice update statement!

So.. if you're not using .Save() already, start doing it for everything: content, media, members, etc. Everywhere you set properties, add a .Save().

Currently the behavior has only changed for Content and Media, but it will change for the other API's as well.

Go get it!

Remember that this is a beta and not everything is perfect yet. But I did drive Morten insane by breaking all kinds of things and installing all of the popular packages, most of which should work in v6. So please, create new issues in the issue tracker when you spot them and set the "Affected Version" field to 6.0.0 so it's clear that they popped up in that release.

Other than that, I think internally we're all very, very excited about this release, paving the way to the future of Umbraco. Surprisingly little seems to have actually broken and that's a great thing!

So head on over to CodePlex and give it a whirl! Bonus tip: You can even upgrade v4 to v6 easily!

Thursday, January 10, 2013 by Sebastiaan Janssen

It's been brewing for a while now, we have the last few remaining issues for 4.11.2 fixed and it's up on CodePlex now! As we promised earlier the nightlies for patch releases are very stable and it's been fun to see people have picked them up and used them, leading to a few more fixes.

The upgrade is really easy and does not break anything, we've even managed to sneak a few things we had to for for v6 into this one. If you're on 4.10.x or 4.11.x it's a highly recommended upgrade, have a look at the list of fixes on the issuetracker.

As you can see, 4.11.2 mainly fixes some publishing problems that have cropped up, so make your editors happy and upgrade as soon as possible. The download is ready for you on CodePlex and of course NuGet has also been updated.

We're not forgetting about you v4 lovers and we're dedicated to providing more bugfixes to v4 in the future.

And yes, a v6 beta is on track to be released very, very soon, hold that thought!

Update: I made some mistakes during the release, oops! Version is all good though. :-)

Monday, January 7, 2013 by Niels Hartvig


Happy New Year!

I can’t remember the last time I’ve been this excited about getting back to work after a holiday. While 2012 in hindsight was about getting lost and messing up, followed by soul searching, finding back to the roots and coming out healthy and strongly of a crisis, this year seems much more bright, especially as we can start building on what we learned last year.

There’s a lot of positive change coming to the Umbraco project over the next twelve months, including two new major versions, followed by the Umbraco-as-a-Service cloud offering we’ve been working on for quite a while here in the HQ. The overall agenda for all three projects, is getting back to the roots of making Umbraco a powerful, yet simple tool to build websites.

The Umbraco Roots (photo by Douglas Robar)

Two new major versions in the horizon - what does that really mean?
A major version of a piece of software can always sound scary and in the world of Umbraco - with v5 in hindsight - it could be nothing short of a horror movie. However, in the core team we’re doing everything we can to make it G rated.

First of all, a new major version doesn’t have to mean major changes - and in particular nothing like v5 brought. Been there, done that, got the t-shirt and not only didn’t it fit, it was also damn ugly. One of the decisions following CodeGarden and the v5 aftermath was to move our versioning to SemVer. It means that if we add changes to the core that could break (but might not for all), we need to bump up the version number. With the coming v6, that’s what we might do.

V6 for dummies

Umbraco 6 is in its final stage of testing and while it looks and behaves just like the Umbraco you know well, it brings a completely new CRUD API. Fancy as it may sound, it simply means that the way that Umbraco creates and updates its data has been completely re-written from scratch, bringing greater performance, less database queries and a core that’s easier to maintain and test. In other words; faster, stronger and eventually more stable.

However, the old APIs will still work. In fact, the backoffice of Umbraco in v6 still uses most of the old APIs. But the core team, have made some super clever engineering that means that even though you call the old APIs, internally your calls will be re-wired to the new APIs. So not only does this mean that we can use the existing back office to test if that really works, your old code will work, just much faster yet you don’t need to do anything. We’d like to call it respecting our legacy.

With v6.1 that follows - knowing that the new APIs worked as we expected -  we’ll be changing the back office to use the new APIs directly and mark the old API methods as obsolete (though you can still use them without build errors). You could call that paving the way for the future of a - code wise - more stable and elegant core codebase.

V7 for dummies

Umbraco v6 and v7 living bon mariage style

While v6 is all about internals and code, ensuring a beautiful inner soul, v7 is all about beauty on the surface. With v7 we’ll be introducing the new UX - the artist also known as project “Belle”. It’ll use the exact same core as v6 - in fact the two versions will be maintained in parallel for quite a while.

Again, we’ll be respecting legacy as people are not forced to jump on a whole new look and feel until it make sense to them (and before it’s completely stable). And again we’ll be paving the way for the future as we can focus on the richer possibilities that modern browsers brings, leaving older browser support at the doorstep of v6 (if your organisation for some reason are forced to stay on an old version of Internet Explorer, you can continue to use Umbraco through the side-by-side maintained v6).

Umbraco as a Service aka “Concorde”

While our baby is still to receive its final name, the final thing in the horizon is our cloud offering of Umbraco, which is the artist formerly known as “Codename ‘Concorde’”. It’s not your usual “CMS hosted in the cloud”, instead we’ve been designing a whole new development and deployment experience with the possibilities that a cloud platform brings us.

There’ll be a lot to talk about and even more to show over the next months, but it’s worth mentioning here as we’ll be able to move existing Umbraco installations onto our new platform opening up a whole new way of developing, sharing and deploying despite you didn’t started out on the “Concorde” platform originally.


So 2013 will bring us three major new goodies; a whole new faster and stable API, a stunning new user friendly look‘n’feel and finally an easier and faster way to develop and deploy your fantastic Umbraco solutions. And all that in a way, that’s compatible with what you know today while giving you the chance to learn smarter ways to do Umbraco in the future.

Wednesday, January 2, 2013 by Per Ploug

It’s the beginning of a new year, and time for new year’s resolutions. We think a very important resolution for any Umbraco developer or company, is getting Umbraco 6 training and certifications, which is why we, right now, offer it at a very special price to celebrate the new year.

An Umbraco Developer Certification helps developers showcase their Umbraco skills, get them jobs, helps companies become official partners and build a solid reputation.

As a special offer, right now you can get unlimited access to umbraco.tv video tutorials, full licenses to Contour and Courier when you sign up for a Umbraco 6 Master Class. That means for the 900EUR course price, you get umbraco.tv and product licenses worth 700EUR included with the course. The next round of classes are in January in Copenhagen, book a seat today before it sell out.

The Level 1 Master Class

Enables web designers to build complete content managed websites with Umbraco from scratch. With full control over html and design, and with a UI that is a pleasure to use for editors. Umbraco 6 comes with a new suite of editor components for easier content management and an overhauled media library which makes media management much more intuitive.  

See if there any available level 1 seats left

The Level 2 master class

For .net developers who understands how Umbraco works, but wants to build advanced applications on top of umbraco or integrate with 3rd party services using Visual Studio. Umbraco 6 comes with a brand new set of APIs which are a pleasure to use combined with full asp.net MVC support giving developers access to a modern developement pattern from Microsoft. Be the first to learn the new, faster way to build Umbraco sites.

See if there any available level 2 seats left

We have announced a full training schedule for the next 6 months, with training locations all over the world, see the full schedule here.

This offer expires on February 1st 2013.