We’ve built the product catalog, the cart, the checkout, the CI/CD pipeline, and everything in between. Eleven posts deep. Time for an honest retrospective.
Part 11 is the Tech Lead’s playbook — the real assessment of the Angular 21 + .NET 10 ecommerce stack, including what nobody tells you until you’re three months in.
📊 Download: Tech Lead Risk Register Diagram (draw.io)
What This Stack Does Well
Type Safety from API to Template
The Kiota codegen pipeline (Part 4) is the best architectural decision we made. When the .NET 10 API adds a discountPercentage field to the Product model, the TypeScript types update automatically in CI. The Angular template that tries to access product().discount fails TypeScript compilation. The developer sees the error in their IDE before a single test runs.
This is not a small thing. This is the difference between catching a contract breach in 30 seconds and catching it in production two days after release.
Signals Genuinely Reduce Complexity
After six months of Signals on a real project, the verdict: they reduce the cognitive overhead of state management significantly. The cart service (Part 5) has 80% fewer lines than its RxJS equivalent would. The product catalog store is readable to developers who’ve never touched RxJS. The real-time stock updates (Part 7) work without a single async pipe.
The one caveat: effect() abuse. Teams new to Signals tend to use effect() the way they used subscriptions — for everything. The actual signal contract is: effect() is for side effects to external systems only. Internal state changes should use computed() or direct update() calls.
.NET 10 Clean Architecture Scales with the Team
Clean Architecture paid off when we added the B2B features in month four. Three .NET developers built the B2B pricing engine independently in the Application layer without touching a single Angular file. The domain model lived in one place. The Angular team consumed a new /api/products?priceTier=b2b query parameter that Kiota generated types for automatically.
This is the actual promise of Clean Architecture: parallel team development without coordination overhead.
Zoneless Angular + SSR Performance
TechShop’s core product pages (measured after Part 7 implementation):
- LCP: 1.8s (target: < 2.5s) ✅
- CLS: 0.03 (target: < 0.1) ✅
- INP: 110ms (target: < 200ms) ✅
Zoneless change detection + Signals + SSR with proper NgOptimizedImage usage hits Core Web Vitals targets without micro-optimization heroics.
What This Stack Struggles With
The Angular 6-Month Release Cadence
Angular 21 was released November 2025. Angular 22 will release in May 2026. Angular 23 in November 2026. A client who signed a 2-year contract now has four major Angular version decisions to make.
The ng update schematics handle 90% of the migration automatically. The remaining 10% — deprecations that don’t have auto-migrations, template compile errors, changed behavior in SSR — requires developer time.
Practical approach for ecommerce projects:
- Budget one sprint (2 weeks) per year for Angular major version upgrades
- Pin to Angular’s LTS versions (even-numbered: 22, 24, 26) for 18-month patch support
- Don’t chase Angular Canary or RC releases in production
NgRx Signals Store Documentation Gap
NgRx Signals Store (v19) is the right solution for complex state, but its documentation is still catching up to the implementation. When we hit a specific issue with withEntities and optimistic updates (Part 6), the answer wasn’t in the docs — it was in a GitHub issue thread from October 2025.
Teams adopting NgRx Signals Store in early 2026 should:
- Allocate budget for exploratory time
- Watch the NgRx Discord and GitHub issues
- Have one team member own the NgRx upgrade path
Onboarding Time for .NET-First Developers
Our structured 4-week curriculum (Part 3) works. The reality: it takes 4 weeks before a .NET developer is independently writing Angular code that doesn’t require immediate correction in code review. It takes 8 weeks before they’re reviewing others’ Angular code effectively.
This is not a criticism of .NET developers or Angular. It’s factual: learning a different reactivity model, template syntax, and module system takes time, even with the best training materials.
Plan your sprint capacity accordingly: a .NET developer is at 50% Angular productivity in weeks 1-4, 75% in weeks 5-8.
SSR + TransferState Still Rough
The resource() API and TransferState integration (Part 7) requires manual wiring. Angular’s withHttpTransferCache() (which auto-deduplicates SSR HTTP calls) works with HttpClient but requires extra work with resource() and Kiota’s Fetch-based adapter.
The Angular team is aware of this. Expect better integration in Angular 22 (May 2026). Until then, use the manual TransferState pattern shown in Part 7.
Risk Register
Every Tech Lead should maintain a risk register for their stack choices. Ours:
| Risk | Probability | Impact | Mitigation |
|---|---|---|---|
| Angular major upgrade breaks SSR routes | Medium | High | Pin to LTS versions; test upgrades in staging first |
| Kiota codegen falls behind .NET 10 API changes | Low | High | CI codegen drift check (Part 10); auto-regenerate on merge |
| NgRx Signals Store breaking change | Low | Medium | Lock NgRx version; read changelog before upgrade |
| .NET dev writes business logic in components | High | Medium | ESLint rule + code review checklist + pair programming |
| Zone.js re-introduced (external lib conflict) | Low | Low | Audit all non-Angular imports for Zone.js assumption |
| Playwright E2E flakiness in CI | Medium | Low | --retries=2, stable selectors, test reset API |
| GitHub Copilot generates outdated patterns | Medium | Low | Workspace instructions (Part 8); review all Copilot code |
The Decisions I’d Make Differently
More investment in the shared/ui library earlier. We started with feature teams building their own buttons and form fields. Two months later, we had six slightly different “primary button” implementations. The shared UI library (Part 2) should have had 10 components before feature work started, not 3.
Signal Forms (experimental) — don’t touch them yet. One developer spent a week building a complex checkout form with Angular 21’s Signal Forms experimental API. We had to rewrite it with Reactive Forms after the Signal Forms API changed in an RC. The “experimental” label means it.
Dedicated Playwright test owner. E2E tests without an owner drift. Team members add tests but nobody removes the brittle ones. Assign one person per sprint to review and prune the Playwright suite.
The Team Advice
If you’re the Technical Lead starting this project today:
From day one:
- Write the
.github/copilot-instructions.mdbefore any code - Set up Nx with boundary lint rules (Part 2)
- Generate the Kiota client and check it into the repo
- Write the first Playwright test immediately (as documentation of intent)
From week 2:
- Start the .NET dev Angular training (Part 3 curriculum)
- Establish the ADR template and document the first three decisions
- Set up CI drift check for API codegen
From month 2:
- Review the NgRx Signals Store decision — if orders are getting complex, add it now before the pain
- Review coverage reports — enforce thresholds in CI before coverage debt accumulates
- Run a mini-retrospective on the pairing model
What success looks like at 6 months:
- Every developer can read every part of the codebase
- No-one is the only person who understands the cart or auth flow
- PR review comments are about business logic, not Angular syntax
- Deployments are boring
Series Summary
This series documented the full lifecycle of building TechShop — an Angular 21 + .NET 10 ecommerce platform — from the Tech Lead’s perspective. Here’s what we covered:
| Part | Title | Key Contribution |
|---|---|---|
| 1 | Tech Lead’s First Week | Stack overview, ADR template, risk assessment |
| 2 | Angular 21 Project Setup | Nx, ESLint flat config, Vitest, Kiota |
| 3 | Training .NET Devs | 4-week curriculum, DI/Signals/RxJS analogies |
| 4 | .NET 10 Integration | OpenAPI codegen, JWT auth, Problem Details, SignalR |
| 5 | Ecommerce Domain Features | Product catalog, cart, multi-step checkout |
| 6 | State Management | Signals vs. NgRx Signals Store decision matrix |
| 7 | Angular SSR Storefront | Route-level rendering, SEO, Core Web Vitals |
| 8 | GitHub Copilot Workflow | Workspace instructions, Angular MCP server |
| 9 | Testing Strategy | Vitest, xUnit, Playwright E2E purchase flow |
| 10 | CI/CD & Automation | GitHub Actions, Docker, Azure Container Apps |
| 11 | Tech Lead Playbook | Retrospective, risk register, honest assessment |
References
- Angular Release Schedule — angular.dev
- Angular Long-Term Support Policy
- NgRx Signals Store — ngrx.io
- Angular SSR with Transfer State
- ADR — Architecture Decision Records
- Google Core Web Vitals
- Playwright Test Stability Guide
- Draw.io Diagram: Risk Register
This is Part 11 of 11 in the Angular Ecommerce Playbook.
Full series: