Tech insights: How ASP.NET Zero Speeds Up Dev Time and Adds Immediate Value to Clients

How ASP.NET Zero Speeds Up Dev Time and Adds Immediate Value to Clients

By Tyler Pieterse

Being tasked with developing a custom solution for a client is exciting for any development team. Less exciting, however, is having to build the same standard — yet essential — features, time and again. These are things like user onboarding, authentication, and management. But, given the importance of these features, no compromise can be made on ensuring their quality implementation.

Here’s how ASP.NET Zero has helped us build these features fast so that we can focus our development time on real solutions for our clients.

How-ASP.NET-Zero-Speeds-Up-Dev-Time-and-Adds-Immediate-Value-to-Clients_Inner-Article-Image-1

At Kohde, we have the opportunity to work with a range of businesses looking for software solutions. No two projects are the same, but almost all of them require standard features.

We found that we were spending a large amount of development time rebuilding the same features for every project that came in, which was a big waste of resources. To solve this, we wanted to find a tool that would allow us to deliver value to the client faster, while also enabling us to pivot more readily as project requirements crystalised.

This solution turned out to be ASP.Net Zero – a base solution that we could use as a plug-and play starter. An off-the-shelf product that acts as a corporate-ready launching platform, ASP.NET Zero has all the components that we needed to implement quality standard features, without having to create all new elements or actively maintain the base.

Here are five features of ASP.NET Zero that have helped our development team save time so that we can double down on solving problems and delighting our customers.

5 features of ASP.NET Zero that help developers build standard features faster and more efficiently

It’s built on mature technologies

ASP.NET Zero is built on mature frameworks, including ASP.NET Boilerplate (ABP) – a thoroughly documented web application framework with a layered architecture and modular design. On the front-end, ASP.NET Zero makes use of Angular and the Metronic theme.

Personally, I’m a big fan of Angular because of the level of structure it offers — particularly in combination with TypeScript, which we use in conjunction with the Swagger integration that ABP offers.

This way, we are able to enforce consistent type mappings between back-end and front-end interfaces. This has helped our developers pick up on integration problems faster.

Note: The Angular compilation time is a bit longer than some other frameworks, especially if you develop on a machine with less memory. Specifically when trying to debug a tricky front-end issue, this can be a bit annoying.

It has versatile authentication options

ASP.NET Zero is based on the ASP.NET Identity Framework, and makes login easier by supporting multiple options for single sign-on. This includes doing so via Active Directory Federation Services (ADFS), or through social media platforms. It also offers several security enforcement features, like two-factor authentication, session timeout, and locking.

Tight security can make live user support challenging and debugging difficult. The ASP.NET Zero base solution implements user impersonation, where an authenticated user can perform a secondary login as another user.

This means no passwords need to be disclosed when providing support. Use of this is typically available to admin users, and is controlled via permissions. It is also extremely useful during development when testing or trying to re-produce a specific user issue.

Note: There may be cases where user impersonation is not desirable. There is no switch to disable it completely. We have had an instance where impersonators needed to be restricted to view-only capabilities, and this was achieved through a custom implementation.

It comes with ready to use environment configurations

No system lives in stasis, and being able to release updates and new features is essential. But with it comes the challenge of managing source control for various environments where code release may not always occur in a linear fashion.

ASP.NET Zero comes packaged ready to select configurations from files based on the environment in context. The configuration options are easy to define and reference in code.

Being able to easily define database and integration connection parameters per environment is useful for making sure that settings don’t land up in the wrong place. This can also be used to facilitate Continuous Delivery, where configurations can be added for release toggles of large features, such that they can be deployed to production while QA is still on-going. If an urgent fix is required, there is less need for hot-fix branching and cherry-pick commits, which might cause problems later if a production branch has started to deviate from the development source.

It has automatic exception handling and logging

Every day, more code is being written that reuses other code, but whether an error comes from within a dependency, or from a local workflow, it becomes a challenge for developers to diagnose the precise cause if proper exception handling and logging are not in place.

Sometimes exceptions can arise from within a dependency, but are ‘swallowed’ by the enclosing system. Other times an erroneous use case has been overlooked, and the exception thrown is only caught in an adjacent segment of code.

ASP.NET Zero is set up to automatically log all exceptions to file, and comes with the logger defined on various base classes. This makes it easier to build detailed exception traces into logical workflows – of course, the onus is still on the developer to take advantage of this.

As an added bonus, ASP.Net Zero comes with predefined exception classes and front-end modals that can be used to provide end users with feedback, right from the point where the error is intercepted in the back-end. In the case of an unaccounted for exception, a generic message is produced. In a perfect world, most of these messages would never be seen by end-users, but having this functionality baked in to the base does come in handy to avoid that awkward moment when a client tells you that they clicked a button and nothing happened.

It uses EntityFramework and Code First Migrations as part of a code-first workflow

Database management is one of the most important parts of building software, but can also be extremely painful, and even hazardous if not done properly.

ASP.NET Zero uses EntityFramework and Code First migrations as part of a code-first workflow.

All database entities, constraints, and behaviours are defined in the code-base, and a console tool is used to generate migration scripts that can both apply the changes, and revert them. The tool can then be used to execute the scripts and push changes to the database. Migrations are tracked and persisted in a linear fashion, and will only be physically applied if the solution can build successfully. At any given time the database has a list of all migrations applied to it, in sequence.

Because we rely on source control to track code in isolated snapshots, and must often move between these, it is necessary to have a means to sync up a database to what is needed as per a particular snapshot or branch, of code. The code-first workflow aims to make the code-base the driver of what the database should look like, with the ability to directly reference what ‘must be’ in the database.

Note: The code-first workflow is not a silver bullet. The onus remains on the developer to pay attention to the auto-generated scripts and consider how they will take effect in various environments. There remain cases where scripts cannot be generated from code. To maintain the proper tracking, a blank migration can be generated from the console tool, and the ‘up’ and ‘down’ scripts can then be manually written. If the database is changed first, before the code, for whatever reason, aligning the code-base and migration history can be frustrating, and there is a risk that a completely valid linear history may be sacrificed to rectify such problems.

In addition to these five features, ASP.NET Zero comes with a number of valuable integrations. We’ve found the following particularly useful:

  • Swagger API documentation
  • Redis for server-side caching
  • Hangfire for background jobs
  • SignalR for push notifications and other real-time connectivity requirements
  • FluentValidation for strongly-typed validation rules

Finally, we like it because it’s flexibly packaged to suit a few tech stack variations:

Screenshot-2020-09-07-at-13.01.55

ASP.NET Zero allows clients to actively collaborate in the development process almost immediately

Because ASP.NET Zero comes as a working piece of software out-of-the-box, built with Continuous Delivery in mind, a working instance can be deployed to a testing environment. This means that clients can almost immediately start test driving the software and provide feedback and insight into what adds value to them and what doesn’t. This also helps us focus our attention on developing deliverables that will have the greatest impact based on the client’s feedback.

We have found that setting this precedent from the outset makes clients feel more comfortable, encouraging them to use their software as it is developed.

After all they are the business experts, and however sophisticated the software, if it does not empower them in their operations, then it is not solving the problem that sent them in search of a software solution in the first place.

If you’d like some more information on ASP.NET Zero, check out their website here. I enjoyed their live demo, which shows you the base solution in action. All you have to do is fill in a mock domain, and you will have your own fully-fledged starter site up and running, where you can login and click through their features – all of which you can also find listed here.

If you do decide to incorporate ASP.NET Zero into your workflow, I’d love to hear if and how it’s helped your team like it’s helped ours!


Tyler Pieterse has been working as a software developer for seven years – although he did take a break from the industry to work in fitness for a bit. When he returned from this brief venture, he found that the skills he picked up in motivating himself and others proved to be very useful in a team setting. When he’s not at his computer solving problems – which is his favourite part of being a software developer – he’s painting or playing the piano.

Subscribe to our blog

Don’t miss out on cool content. Every week we add new content to our blog, subscribe now.

By subscribing you agree to our Ts & Cs and our Privacy Policy, including our use of cookies.