Architecture Portfolio
A curated portfolio of architecture-led platforms, working software products, and reference implementations spanning AI, identity, modernization, and financial technology.
Platforms
Foundational capabilities designed for reuse, trustworthy integration, and long-term evolution.
Repo Analyzer
A multi-tenant repository intelligence and architecture governance platform for .NET. Turns Git repositories into transparent rule-based assessments, dependency and C4 views, baseline comparisons, and evidence-backed AI architecture reviews. Teams can inspect findings, prioritize improvements, and export results through a Blazor portal, APIs, or MCP integrations.
Architecture notes
Repeatable assessment. Analyze an entire repository or selected projects against database-backed architecture, security, dependency, testing, documentation, and operations rules. Shared profiles and tenant-specific overlays support consistent evaluation with explainable scores and persistent analysis history.
Traceable architecture reviews. Combine deterministic findings with retrieved standards to summarize strengths, risks, and priority recommendations. Versioned reviews retain source-run provenance and separate AI interpretation from human finding dispositions; baseline deltas and Markdown/JSON exports support ongoing review.
Reusable integration. Clean Architecture separates analysis from the Blazor portal, gRPC/JSON and HTTP APIs, and MCP HTTP/stdio hosts. Microsoft Entra sign-in, tenant isolation, roles, feature entitlements, and quotas govern access. AI and retrieval backends support Azure AI Foundry + Azure AI Search or Ollama + Qdrant.
Zenvera Identity
A central authentication and standards-based Single Sign-On platform for independently deployed applications. Unifies email/password accounts and Microsoft or Google sign-in with account verification, recovery, token issuance, and governed application admission. Each product retains ownership of its business roles, tenant membership, and authorization policies.
Architecture notes
One identity authority. Built with Clean Architecture, .NET 10, ASP.NET Core Identity, OpenIddict, and SQL Server. Local and federated sign-in share a canonical session and stable public user identity; account verification, password recovery, and account lifecycle controls support consistent onboarding.
Controlled application access. Registered clients use OpenID Connect authorization code flow with S256 PKCE and confidential-client authentication. Database-backed admission policies check account eligibility and application access during authorization and code exchange; administrators can manage users and product-access grants.
Clear security boundaries. Product authorization stays within each application. Sensitive administrative changes require recent authentication, while encrypted queued email and structured audit events support account operations. Central sign-out clears the Identity session; existing product sessions follow their own logout policies.
Zenvera CMS
A multi-site publishing platform that serves independent websites from one .NET 10 and Blazor Server application. Domain-based resolution selects each site’s content, branding, settings, and layout, while a shared administration surface manages publishing. Tenant-aware SEO and PWA features give each site its own public identity and installable experience.
Architecture notes
Independent sites, shared platform. Request-scoped tenant resolution matches configured domains and aliases to a blog. Content and settings are scoped by BlogId, while structured presentation settings control site layouts, sidebars, hero defaults, and route-specific overrides.
Complete publishing workflow. Manage posts, pages, categories, tags, comments, accounts, and visitor records through focused application services. Clean Architecture keeps domain rules separate from publishing workflows, EF Core persistence, and the Fluent UI Blazor presentation layer.
Discoverability and delivery. Site-aware titles, descriptions, Open Graph and Twitter metadata, canonical URLs, robots configuration, and syndication support discovery. Dynamic PWA manifests, static-asset caching, and an offline fallback support installation and repeat visits; memory caching, pooled database contexts, and response compression improve delivery efficiency.
Reference Architectures & Labs
Runnable experiments and comparison implementations used to validate architectural trade-offs.
Identity Architecture Lab
A reference lab exploring identity and access management using a single gRPC + JSON transcoding API, demonstrated through two independent UI strategies—a Blazor Server admin portal and a Blazor WebAssembly shell hosting an identity-management micro-frontend. Both consume the same backend contracts without any duplication of identity logic.
Architecture notes
The backend API is implemented with gRPC and protobuf contracts as the source of truth. JSON transcoding exposes the same service methods as REST-style HTTP endpoints, allowing native gRPC clients (used by Blazor Server) and browser HTTP clients (used by the WASM MFE) to share one contract surface without a separate REST controller layer. Authentication covers local JWT issuance and rotation, refresh token lifecycle, secure credential validation, and optional Microsoft Entra integration—all enforced through a layered interceptor chain.
The Blazor Server portal demonstrates the API through configurable client strategies selected at runtime. The Blazor WASM path demonstrates a micro-frontend composition model: a portal shell authenticates the user, then loads the user-management MFE in a sandboxed context and establishes secure communication channels. The MFE receives authentication context, manages session state, and makes authenticated HTTP calls to the identity API independently.
Identity data is persisted in SQL Server with entities covering users, clients, access assignments, and API credentials. Sensitive credentials are stored using industry-standard hashing—plaintext values are returned once at creation and never persisted. The platform supports both local identity users and Microsoft Entra-linked users within a unified user model, with account lifecycle states enforced at authentication time.
HourTracker
A Blazor WebAssembly time tracking application that demonstrates runtime-switchable backend integration— the same UI pages and service abstractions operate against either a REST API or a GraphQL API through configuration, without any change to the UI layer.
Architecture notes
The Blazor WASM client depends exclusively on service abstractions for data access. At startup, configuration determines which concrete implementation is registered— either REST-based or GraphQL-based. UI pages for business entities call the same interface methods regardless of which backend is active—the protocol switching is entirely below the UI layer with no conditional logic in components.
The REST API is built on ASP.NET Core controllers with JWT bearer authentication, API versioning, and Swagger documentation. The GraphQL API uses HotChocolate with type-safe query and mutation patterns and custom middleware for user context resolution. Both APIs share a common library containing the EF Core DbContext, domain models, DTOs, mapping profiles, and business services— keeping domain logic and persistence unified regardless of which API surface is consumed. Business data is stored in SQL Server with soft-delete and audit capabilities on all entities. Structured logging captures both application and audit-oriented events.
Zenvera .NET Examples
A curated collection of runnable .NET reference implementations covering API styles, authentication, Clean Architecture, integration patterns, infrastructure concerns, and user-interface approaches.
Includes practical examples for REST, gRPC, GraphQL, SOAP, API gateways, authentication mechanisms, Redis, RabbitMQ, Azure Key Vault, Serilog, and Blazor. Each example is designed to demonstrate architectural trade-offs without unnecessary production complexity.
Zenvera AI Examples
Focused .NET 10 examples for Microsoft.Extensions.AI: streaming chat, retrieval-augmented generation, Model Context Protocol, Microsoft Agent Framework, Aspire grounded chat, and adding AI to an existing app.
Each example is independently runnable. Foundry, Ollama, and a no-network Mock provider are selected with configuration rather than duplicate projects, so the same code path can be learned locally or against a cloud endpoint.
Across these platforms, products, and reference labs, the common thread is architectural discipline: clear boundaries, proportionate systems, security-conscious integration, and maintainable software built for long-term evolution.
Platform Modernization
Microsoft Certified:
Azure Solutions Architect Expert
