ASP.NET Core 9 Essentials • Albert Tanure & Rafael Herik de Carvalho • GOTO 2025

Albert Tanure's "ASP.NET Core 9 Essentials" is structured to guide developers through the entire application lifecycle, starting with foundational .NET concepts and culminating in modern cloud-native principles. The book emphasizes understanding not just the code, but also the operational aspects like DevOps, observability, and dynamic configuration necessary for building and maintaining applications in today's dynamic cloud environments.

October 9, 2025 4 min read

ASP.NET Core 9 Essentials • Albert Tanure & Rafael Herik de Carvalho • GOTO 2025 — source: https://www.youtube.com/watch?v=GqJfsDJuwCI

In “ASP.NET Core 9 Essentials,” author Albert Tanure presents a structured journey designed to take a developer from core concepts to building and operating modern, cloud-native applications. The book’s philosophy is to mirror a real-world development process, establishing a strong foundation before introducing more complex best practices and operational concerns.

A Deliberate Journey from Foundations to Cloud-Native

The book is intentionally structured to build knowledge progressively, like climbing a set of stairs to the cloud. It begins with the fundamentals of application development before layering on advanced topics.

Foundations First: The initial chapters cover building dynamic UIs, crafting web APIs, managing data persistence, and implementing security. This approach ensures that a developer has a solid, working application before optimizing it.
Best Practices in Context: Best practices, such as dependency injection, are introduced later. This was a deliberate choice to help developers first understand the problems that these patterns solve. By encountering potential issues like object lifecycle management in simpler code, the reader can better appreciate why a specific best practice is valuable, rather than treating it as an abstract rule to be followed.

Embracing the Full Application Lifecycle

A key theme of the book is that modern development extends far beyond writing code. It covers the entire lifecycle, equipping developers with the knowledge to build, deploy, and operate software effectively. This includes crucial operational aspects such as:

Hosting and deployment strategies.
Monitoring application health and performance.
Managing and optimizing cloud costs.
Adopting a cloud-native mindset.

The Cloud-Native Mindset: Beyond Hosting

The later chapters, particularly 9 through 11, focus on the shift in thinking required for cloud-native development. It’s not merely about deploying an application to the cloud, but about designing it to thrive in a dynamic, distributed environment.

Dynamic Configuration and Security: Developers must move away from static configuration files and avoid bad practices like storing secrets in appsettings.json. The book introduces tools like Azure App Configuration to manage settings dynamically across different environments and implement feature flags for strategies like A/B testing.
Thinking in an Ecosystem: Applications no longer work in isolation. A modern developer must understand how their service interacts with a broad ecosystem of tools and technologies. The book encourages looking beyond a single framework to integrate with the best available solutions, whether for feature flagging, caching, or observability.
Continuous Evolution: In the cloud, an application is never “done.” As soon as it’s deployed, it’s on its way to becoming legacy. Developers must adopt a mindset of continuous improvement and be prepared to evolve their applications constantly.

The Role of Modern Tooling: Containers, Observability, and .NET 9

To support this modern approach, the discussion highlights several key technologies and concepts that are essential for today’s developers.

Containers: Containers are presented as a critical tool for packaging an application with all its dependencies, ensuring consistency from the developer’s machine to the production environment.
Observability: A significant focus is placed on observability—a concept often missed by developers. It’s about gaining deep insights into an application’s behavior through logs, metrics, and traces. The framework’s ILogger is a starting point, but the goal is to adopt comprehensive tools like OpenTelemetry. This vendor-neutral standard allows developers to instrument their code once and send telemetry data to various backends (e.g., Application Insights, Dynatrace), which is crucial for diagnosing performance issues and understanding distributed systems.
.NET 9 and .NET Aspire: The .NET 9 framework is described as being well-prepared for cloud-native challenges, with excellent support for OpenTelemetry and a flexible, open-source nature. While .NET Aspire is a powerful tool for simplifying the local development of cloud-native apps (by managing service discovery and dependencies), it was intentionally excluded from this “essentials” book. The author felt it was more important for readers to first understand the fundamental concepts that Aspire abstracts away, such as DNS and service-to-service communication.

Guidance for Developers

The book is designed to be valuable for developers at different stages of their careers.

For those new to .NET: It is recommended to read the book from beginning to end to build a solid, holistic understanding of the platform and modern development practices.
For experienced developers: While the fundamentals may be familiar, the later chapters (9-11) are highly recommended. They provide valuable insights into cloud-native strategies, design patterns, and operational considerations that are relevant to any senior developer or architect.