Performance & Observability for Angular + .NET (Microservices)

Modern applications are rarely a single deployable unit. A single click in an Angular interface can trigger a chain of API calls, database queries, and asynchronous messages across several .NET services. When something runs slowly, the cause is seldom obvious, and guessing is expensive.

This 3-day, hands-on course teaches a structured approach to finding and fixing performance problems across the full stack. You will start by learning to see the system: instrumenting Angular and .NET applications, correlating logs, metrics, and traces, and following a single request from the browser through services, databases, and message queues. You will then learn to fix it, applying proven optimization techniques to Angular rendering and state management, .NET backend code, MSSQL queries, and messaging consumers.

Finally, you will practice investigating realistic production scenarios and validating your improvements with load testing.

Each day includes a lab built around a deliberately slow system, so you leave with practical experience of measuring a problem, identifying its root cause, applying a fix, and proving the result. The course emphasizes a repeatable investigation method over tool-specific tricks, so the skills transfer to whichever observability stack your organization uses.

Target Audience

This course is designed for engineers who build and support Angular and .NET systems in distributed environments, including:

• Full-stack developers working across Angular front ends and .NET microservices.

• Backend (.NET) developers who want to diagnose and improve service and database performance.

• Frontend (Angular) developers who want to understand how API, network, and rendering behavior affect user experience.

• Tech leads and software architects responsible for the performance and reliability of distributed systems.

• DevOps, SRE, and platform engineers who support these applications and want to understand application-level telemetry.

• QA and performance engineers who are moving into load testing and performance investigation.

Prerequisites

Required

• .NET experience: Working knowledge of C# and ASP.NET Core Web APIs, including async/await and dependency injection.

• Angular experience: Practical experience building Angular applications, including components, services, RxJS, and HTTP communication.

• Database basics: Familiarity with relational databases and SQL (SELECT, JOIN, WHERE, indexes), preferably Microsoft SQL Server, and some exposure to Entity Framework Core or another ORM.

• Architecture basics: General understanding of REST APIs and the principles of microservices architecture.

• Tooling: Comfort using a code editor or IDE, the command line, and browser developer tools.

Recommended (not required)

• Basic understanding of messaging concepts such as queues, publishers, and consumers (e.g., RabbitMQ, Azure Service Bus).

• Familiarity with NgRx or a similar state management approach.

• Basic exposure to Docker and containerized environments.

• Prior experience with logging or monitoring tools.

Technical Requirements

• A laptop with administrator rights, a modern browser (Chrome or Edge), and a stable internet connection.

• Docker Desktop (or an equivalent container runtime), plus .NET SDK, Node.js, and an IDE such as Visual Studio, VS Code, or Rider.

• Lab environments will be provided as ready-to-run projects and containers, so no prior setup of observability tools is needed.

Course Outcomes

By the end of this course, participants will be able to:

• Trace requests across distributed systems.

• Diagnose frontend and backend performance issues.

• Optimize Angular and .NET applications.

• Analyze database and messaging bottlenecks.

• Use observability tools effectively.

• Conduct structured performance investigations.

Course Outline

Module 1: Modern Performance in Distributed Systems

• Challenges of performance in microservices architecture

• End-to-end latency breakdown:

  • Frontend

  • API

  • Database

  • Messaging

• Golden Signals:

  • Latency

  • Throughput

  • Errors

  • Saturation

Module 2: Observability Fundamentals

• Logs vs Metrics vs Traces

• Correlation IDs and request tracking

• Introduction to distributed tracing

Module 3: Observability Tooling

• Application Performance Monitoring (APM)

• Dashboards and visualization

• Metrics monitoring with Grafana

• Overview of telemetry pipelines

Module 4: Instrumenting .NET Applications

• Logging strategies and best practices

• Implementing correlation IDs

• Tracking dependencies:

  • Database calls

  • External APIs

  • Messaging systems

Module 5: Instrumenting Angular Applications

• Capturing API performance metrics

• Error tracking

• User interaction timing

• Sending telemetry to backend systems

Lab — Trace a Request Across the System

• Trigger and capture a slow request

• Trace request flow across services

• Identify latency sources using observability tools

Module 6: Angular Performance (Large Applications)

• Change Detection strategies (Default vs OnPush)

• Component design patterns (smart vs presentational)

• State management performance (NgRx):

  • Selector memoization

  • Avoiding unnecessary subscriptions

• Reducing rendering overhead

• Lazy loading modules

• Virtual scrolling for large datasets

Module 7: Frontend Performance Diagnostics

• Using browser developer tools:

  • Performance profiling

  • Network analysis

• Identifying:

  • Slow rendering

  • Large payloads

  • Blocking operations

Module 8: .NET Backend Performance

• Common backend performance issues

• Async/await best practices

• Avoiding blocking calls

• Efficient serialization and response handling

• Caching strategies

Module 9: Database Performance (MSSQL)

• Identifying slow queries

• Understanding execution plans

• Indexing strategies

• Avoiding common ORM pitfalls

Module 10: Messaging and Queue Performance

• Understanding queue delays

• Consumer performance tuning

• Handling retries and failures

Lab: Fix the Slow System

• Analyze a system with performance issues

• Identify bottlenecks across layers

• Apply optimizations:

  o Frontend improvements

  o Backend fixes

  o Database tuning

Module 11: Scenario-Based Troubleshooting

Scenario 1 — Slow Frontend Dashboard

• Multiple API calls

• Large payloads

• Inefficient data loading

Scenario 2 — Intermittent API Timeouts

• Database contention

• Missing indexes

• Query inefficiencies

Scenario 3 — Messaging Delays

• Backlogged queues

• Slow consumers

• Retry-related issues

Scenario 4 — Performance Degradation in Production

• Environment differences

• Network latency

• Resource scaling issues

Module 12: Test Data Generation for Performance Testing

• Importance of realistic data

• Generating large datasets

• Ensuring consistency across services

• Data seeding strategies

Module 13: Load Testing Fundamentals

• Introduction to load testing concepts

• Key metrics:

  • Response time

  • Throughput

  • Error rates

• Overview of common tools (e.g., k6, JMeter)

Lab — End-to-End System Investigation (Capstone)

• Analyze a system with multiple performance issues

• Use observability tools to trace and diagnose problems

• Identify root causes across components

• Propose and implement improvements