Udacity Project Review: Ensuring Quality Releases

Discover Udacity's 'Ensuring Quality Releases' course through our detailed review. We delve into its use of Azure, offering insights into modern app development and quality assurance. Explore the balance of educational depth and practical challenges in this comprehensive guide.

Udacity Project Review: Ensuring Quality Releases
Udacity's Ensuring Quality Releases


In exploring the Ensuring Quality Releases project within Udacity Cloud DevOps using Microsoft Azure Nanodegree, we delve into the intricate balance between delivering critical knowledge for modern application development and the practicalities of online learning.

This segment of the nanodegree teaches skills for deploying, testing, and monitoring cloud applications on Azure. Students learn and use practical tools such as Selenium, Postman, Azure Monitor, and Azure Log Analytics, gaining hands-on experience with tools applicable to real-world scenarios​​.

However, to accommodate the online learning model and make the course more widely accessible, the project has undergone simplification. While broadening reach, this approach sometimes masks the full complexity of cloud application management. As a result, learners may encounter challenges in fully grasping or completing specific parts of the project.

On top of that, some course materials, including video tutorials, need to be updated. For instance, one video references the provision of free Azure credits to students, a no longer relevant feature. Udacity now offers an Azure lab environment, creating a temporary user for each student. While a helpful tool, this lab has limitations, particularly the time restriction of 11 hours for students to complete this project or the limitation to a single pre-created resource group.

In this article, we hope that by pointing to those issues and explaining their reasons, We'll help students avoid frustrations and successfully achieve their learning goals.

Painpoints of the ‘Ensuring Quality Releases’ Project

Understanding Prerequisites for the Course

The Ensuring Quality Releases project is marked as an intermediate-level course. Still, the requirements could state more clearly the knowledge required to grasp the course material and project steps fully.

These requirements are not necessarily due to hands-on tasks but to help students understand the content presented.

Key areas where additional knowledge is beneficial include:

  • REST APIs: Understanding RESTful APIs helps comprehend course materials involving web services. Fortunately, Udacity offers a free course about REST APIs.
  • Software Development Principles: The course does not include any coding, but familiarity with basic software development concepts aids in making sense of the testing and deployment discussions in the course.
  • Linux & Scripting Skills: Knowledge of Linux helps understand server management and script execution tasks. Students should understand the PATH, know how to declare and set environment variables, be familiar with Bash, and be able to write simple scripts. This is especially important now that Azure does not auto-provision Pipeline machines, and students must create and configure a Virtual Machine in Azure to execute the Pipeline Jobs.
  • GIT Knowledge: Given that the subject is quality releases, It should be apparent from the subject that familiarity with GIT and GitHub is necessary.

Awareness of these skills can help students better navigate the course, making the learning process smoother and more coherent.

Absence of a Unified Sample Application

The biggest problem with the Ensuring Quality Releases project is that it needs a single, continuous sample application that runs through the pipeline from beginning to end. This impacts the learning experience in several ways.

Each part of the project is informative and valuable, but because these parts operate somewhat independently, the connection between different stages of the DevOps pipeline can appear less evident. In a real-world scenario, understanding how coding, testing, deployment, and monitoring interlink is essential, and this holistic view is only apparent with a single application linking the steps.

Moreover, each step's real-world relevance and operational significance in the DevOps process could become less apparent when not demonstrated through a continuous project. An end-to-end application would make it easier to see the direct impact of actions at each stage and help in appreciating how each component, from coding to monitoring, contributes to the overall success of a software project.

Understanding this structure is crucial for students as it shapes how they approach and comprehend the course material. We hope that pointing this out in this article will help students maximize their learning experience by realizing that each step increases the application's quality.

Testing Sequence and Scope

The next biggest shortcoming is the order and scope of testing presented in the curriculum. The current Performance, Functional, and Integration Testing sequence makes seeing a flow of increased quality assurance challenging.

In a typical DevOps workflow, the testing sequence is crucial and generally follows a different progression with some steps testing the artifacts produced by the previous steps:

Building the software:

  1. Compile/Lint: Initially, the code is compiled, and linting is performed to ensure coding standards and syntax correctness.
  2. Unit Testing: This involves testing individual components or units of the source code, usually before integration.
  3. Packaging: This could be as simple as creating a zip file containing the application or as elaborate as building an image for deployment in a container engine like Docker.

The result from this step should flow through the different testing phases, in a process sometimes referred to as binary promotion.

Also, there is no requirement for the output of this step to be a single artifact; it could be multiple, for example, an image for the application backend and another for the front end.

Testing and Binary Promotion:

  1. Deploy Test Environment: In this step, we deploy the application to a test environment where we run different tests.
  2. Integration Testing: In this stage, we'll usually test the application's backend by using REST APIs to access it. They don't include the UI but should test across multiple layers behind the API, like a database.
  3. UI/Functional Testing: In this step, we would test the UI of our application if it has one. Typically, the UI would use the previously tested API instead of having a different execution path.
  4. Performance Testing: Finally, the application undergoes performance testing to evaluate its behavior under various conditions. We should include the UI or not, but we should do performance testing for the back end using the API access.

The deviation from this sequence in the Ensuring Quality Releases project might impact learners' understanding of the optimal testing flow in a real-world DevOps environment. Notably, the omission of unit testing and the initial focus on performance testing could lead to a skewed understanding of the testing priorities in software development.

Dependence on Third-Party Websites for Testing

Another issue in the Ensuring Quality Releases project is its reliance on third-party websites for UI and integration tests. This approach introduces complexities that are not typical real-world scenarios and can prevent the students from passing the project for no fault of their own. For example, at times, the website used for Integration Testing has been down or introduced request throttling, making it very hard to execute all tests successfully.

DevOps pipelines are designed to be within the development team's test application control in most things professional. This ensures consistency, reliability, and relevance of the tests being conducted.

Performance Testing with Pre-Compiled ASP.NET Website

The final issue in the Ensuring Quality Releases project arises during the performance testing segment. Here, students must deploy an Azure App using a pre-compiled ASP.NET website. This approach, while meant to simplify the process, brings its own set of complexities and limitations:

  • Unrealistic Scenario: In a typical DevOps environment, deploying pre-compiled binaries without compiling is not the norm. This can give a skewed understanding of the deployment process, which usually involves compiling from source code.
  • Complexity for Non-.NET Developers: For students unfamiliar with .NET development, deploying a pre-compiled ASP.NET application can be challenging. Without the ability to run the application locally, they might have to follow the deployment instructions without fully understanding the process.
  • Debugging Difficulties: If students encounter issues during deployment, debugging can become particularly difficult unless they have prior knowledge of .NET.

This aspect of the performance testing exercise could hinder students' learning experience. While the intention might be to streamline the deployment process, it may inadvertently lead to student frustrations and maybe even abandon the learning path because of the difficulties of dealing with problems of a black box application.

Conclusion: Valuable Knowledge Amidst Shortcomings

Despite its shortcomings, the Ensuring Quality Releases project in the Udacity Cloud DevOps using Microsoft Azure Nanodegree offers valuable knowledge crucial for anyone venturing into the cloud applications and DevOps field. The course covers fundamental aspects of deploying, testing, and monitoring applications in a cloud environment, providing a solid foundation in these areas.

While the course has challenges, such as the absence of a unified sample application, an unconventional order of testing, unclear prerequisites, reliance on third-party websites for testing, and pre-compiled ASP.NET websites for performance testing, these only partially diminish its educational value. Each module presents learners with relevant concepts and practices in the contemporary DevOps landscape.

Instead of listing the issues, we'll suggest an alternative approach in future articles, using the same application for all the steps. This alternative method will provide learners with a more comprehensive understanding of the DevOps pipeline, from development to deployment, ensuring a smoother transition of skills to real-world applications.

Please stay tuned for articles [1, ] that will help you through this improved learning journey, designed to complement the skills and knowledge acquired in the Udacity Nanodegree and excel in cloud DevOps.

Addendum: A Special Note for Our Readers

I decided to delay the introduction of subscriptions, you can read the full story here.

In the meantime, I decided to accept donations.

If you can afford it, please consider donating:

Every donation helps me offset the running costs of the site and an unexpected tax bill. Any amount is greatly appreciated.

Also, if you are looking to buy some Swag, please visit I invite you to visit the TuringTacoTales Store on Redbubble.

Take a look, maybe you can find something you like: