ePUAP / login.gov
furtak.dev
Identity integration case study
ePUAP / login.gov Integration Portfolio
A cross-stack identity integration lab focused on protocol workflows: SAML request/callback handling, artifact-oriented resolution, certificate-aware processing, SOAP/WSDL service clients, OpenAPI contracts and typed frontend/backend handoffs.
Why this portfolio exists
Not a frontend-only story.
The project presents a recruiter-friendly identity integration case study built around a realistic engineering scenario: browser-level flow inspection, backend API design, identity protocol research, generated service clients, contract generation and certificate-heavy troubleshooting.
The goal is to show how I reason across the whole integration path when an Angular application touches older enterprise and public-sector systems: redirects, signed XML, generated DTOs, SOAP service models, callback handling and protocol-level failures.
Technology map
A broader stack, presented as one system.
Angular + TypeScript
Browser harness for initiating login flows, inspecting redirected states, rendering typed API responses and making callback/error behavior visible during cross-stack experiments.
NestJS API
TypeScript backend lane for controller/service structure, SAML-style endpoint shape, DTO modeling, Swagger documentation and comparison against the frontend contract surface.
ASP.NET Core / .NET 8
C# backend lane for typed controllers, request/response DTOs, OpenAPI generation, certificate-aware processing helpers and SAML request/response handling experiments.
Java / Spring + CXF
Enterprise integration lane for JAX-WS/CXF clients, WSDL-generated models, XMLSec/OpenSAML-oriented flows, signing utilities and artifact-resolution research.
SAML, certificates, XML
AuthnRequest construction, callback handling, artifact correlation, XML signing, canonicalization concerns, certificate validity and protocol validation.
SOAP/WSDL + OpenAPI
SOAP service descriptions, generated Java models, Swagger visibility, OpenAPI schemas and generated TypeScript models used as typed integration contracts.
Technical depth
The integration concerns behind the technology list.
SAML flow mechanics
The lab models the moving parts around authentication request generation, browser handoff, callback handling, artifact correlation and response interpretation. The case study highlights the places where identity integrations usually fail and how those failures travel between browser, API and protocol layers.
- request initiation and redirect/form handoff
- callback state and correlation concerns
- artifact-oriented response handling
XML and certificate concerns
The interesting work is not just calling an API. XML signatures, canonicalization, certificate validity windows and protocol checks can break otherwise correct application code, so the lab treats them as first-class integration concerns.
- signature and canonicalization awareness
- certificate-aware request/response processing
- validation flow design across identity callbacks
Generated contracts
Multiple backend tracks are useful only if the interfaces remain visible. Swagger/OpenAPI and generated TypeScript models make request and response shapes inspectable from Angular, while WSDL-generated Java models cover the SOAP side of the lab.
- OpenAPI schemas for API visibility
- generated TypeScript frontend models
- WSDL-generated service/client models
Failure-mode analysis
The case study highlights how integration failures surface across layers: browser redirects can hide backend state, protocol errors can look like application errors, and certificate/configuration problems need a different debugging path than ordinary HTTP bugs.
- redirect and callback visibility
- protocol vs. application error separation
- risk-area documentation for technical review
What I built
Concrete artifacts behind the portfolio story.
Browser-facing integration harness
A focused Angular client for triggering flows, inspecting backend responses, previewing protocol handoffs and keeping callback/error behavior visible during experiments.
Parallel backend prototypes
NestJS and ASP.NET Core tracks used to compare endpoint structure, DTO design, OpenAPI output, SAML-style flow handling and certificate-aware helper placement.
Java enterprise integration lane
Spring, JAX-WS, Apache CXF, XMLSec and OpenSAML-oriented research for SOAP/WSDL clients, generated service models, signing utilities and artifact-resolution style workflows.
Presentation-ready case study
A polished portfolio package that turns complex integration work into a clear technical story for recruiters, hiring managers and technical reviewers.
AuthnRequest
Artifact
Response
Certificate-aware flow
signing, validation, callbacks
Architecture view
A lab designed to compare implementation paths.
Angular client
Trigger and inspect
Login actions, redirects, API calls, typed responses and callback states.
NestJS API
Node prototype
.NET API
C# prototype
Identity core
SAML and certificates
AuthnRequest, callback, artifact correlation, XML signatures and certificate checks.
Java services
SOAP/WSDL track
CXF clients, generated models and document-service interfaces.
Design decisions
The engineering choices behind the lab.
Use Angular as an inspection surface, not just a UI layer
Authentication and document workflows are easiest to reason about when browser-side behavior is visible: redirects, generated handoff forms, callback timing, typed API responses and error states can be inspected from the same place where users experience the flow.
Compare backend tracks instead of forcing one default stack
SAML, SOAP/WSDL and certificate-heavy work has different tooling strengths across Node, .NET and Java. Keeping the tracks separate made it possible to compare library support, XML/security tooling, generated-contract workflows, debugging ergonomics and long-term maintainability without hiding the tradeoffs.
Keep contracts visible between frontend and backend
Swagger/OpenAPI and generated TypeScript models reduce ambiguity when several runtime stacks need to agree on request and response shapes. The contract layer becomes the shared language between Angular screens, Node/.NET APIs and service-client experiments.
Translate complex integration work into a clear portfolio story
The case study connects architecture, tradeoffs, validation concerns and runtime choices into a narrative that is readable for recruiters while still giving technical reviewers enough substance for a deeper conversation.
Recruiter evidence
What this case study should make obvious.
Backend literacy without losing frontend focus
The Angular client stays part of the story, but the visible work moves through API design, protocol flows, service clients and generated contracts.
Comfort with difficult integration surfaces
SAML, SOAP, XML signatures and certificates require careful debugging habits. The portfolio frames those constraints in a way that is understandable for both engineering and recruitment conversations.
Comparative engineering judgment
Running Node, .NET and Java tracks side by side creates a concrete basis for discussing tradeoffs instead of presenting a single technology as the default answer.
Integration path
From browser flow to verified service integration.
-
01
Map the integration path
Identify where browser flows, API endpoints, certificates, callbacks and external identity services meet.
-
02
Prototype across stacks
Compare NestJS, ASP.NET Core and Java/Spring approaches without forcing every experiment into one backend.
-
03
Keep contracts visible
Use Swagger/OpenAPI and generated TypeScript contracts to make frontend/backend agreement inspectable.
-
04
Package the case study for technical review
Present architecture, decisions, technology tradeoffs and validation concerns in a clean visual format that supports a focused interview or client conversation.
Project value
Practical value for teams working with complex integrations.
Cross-team vocabulary
The project translates backend identity concerns into frontend-visible behavior: redirects, callback timing, typed responses, service failures and certificate-related edge cases become easier to discuss.
Pragmatic stack evaluation
Keeping Node, .NET and Java lanes visible makes technology choices less theoretical. Each stack is evaluated against protocol support, generated contracts, debugging ergonomics and maintainability.
Technical communication
The case study turns a difficult integration area into a clear, visual and technically grounded portfolio piece that supports recruitment, client conversations and deeper engineering review.