Two Engagements. One Company. Six Years.
Travelers Insurance is not a startup. It is one of the largest property casualty insurers in the United States — a company where software sits beneath billions of dollars in underwriting decisions, claims processing, and risk assessment. Working inside an organization at that scale means operating in an environment where every architectural choice carries institutional weight, and where a tool that proves itself in one corner of the enterprise can spread to every other corner without anyone asking permission.
The six-year engagement with Travelers unfolded in two distinct phases: first as an outside consultant embedded in the Customer Value Stream, then as a direct hire brought in to lead the company’s BSI Construction business segment engineering organization. The two phases were related but structurally different — and the most interesting story spans the transition between them.
The First Act
The first engagement began in 2018 as a consultant embedded in Travelers’ Customer Value Stream organization. The environment was a mixed-generation technology stack — PCF (Pivotal Cloud Foundry) for deployment, Jenkins and IBM UrbanCode Deploy for CI/CD, legacy AngularJS frontends alongside newer React applications, and a data layer that reached from SQL Server and DB2 all the way back to IBM mainframes.
The initial scope included a migration effort, moving AngularJS applications to React, and feature development on the BIFNOL application — a Business Insurance First Notice of Loss system built in ReactJS. The work was technically routine for an engineer at this level: the environment was complex, but the task of moving a well-understood frontend framework to a better one is a known problem with known solutions.
What was not routine was what happened next.
BIFNOL — Business Insurance First Notice of Loss
BIFNOL was a claims intake application for commercial insurance customers reporting first notice of a loss event. The system connected ReactJS on the frontend to a backend data layer spanning SQL Server, DB2, and IBM mainframe records — the layered reality of enterprise systems that were built in multiple decades and never fully consolidated. The work involved understanding that full data topology, not just the green-field React layer on top of it.
The Proxy That Went Everywhere
Within the consulting engagement, a need emerged that no existing Travelers tooling addressed cleanly: a lightweight, configurable messaging proxy that could sit between services and handle translation, routing, and protocol bridging without requiring each team to solve the same integration problem independently.
The proxy was built in Node.js with Express and Redis. It was not designed to become an enterprise standard. It was designed to solve a specific problem for a specific team. The architecture was clean, the performance was strong, and the abstraction was general enough that other teams could adopt it without modification.
That is what happened. The proxy spread laterally across the Travelers engineering organization, adopted by team after team as they encountered the same integration challenges it had been built to address. By the time the consulting engagement transitioned into a direct hire, the proxy was no longer one team’s tool — it was enterprise infrastructure.
This is the kind of outcome that distinguishes solutions built on genuine architectural thinking from solutions built to satisfy a ticket. The proxy worked because its design was rooted in understanding the problem space at an enterprise scale, even when the immediate scope was a single team. It was built to last.
The Proxy Layer
A lightweight service that absorbed the complexity of inter-system communication, allowing consuming teams to integrate through a single well-defined interface regardless of what was behind it.
- Node.js runtime with Express routing
- Redis for session state and caching
- Protocol translation across service types
- Configurable routing and transformation rules
- Stateless request handling for horizontal scale
Enterprise Adoption
What began as a solution for one team’s integration problem propagated across the Travelers engineering organization as each downstream team encountered the same class of challenge.
- Adopted by multiple engineering teams without modification
- Established as the recommended integration pattern
- Reduced duplicated integration logic across the org
- Created a common vocabulary for inter-service communication
- Informed the architecture of Phase 2 platform design
Director of Engineering — BSI Construction
The return in 2022 was a different kind of engagement. As a direct hire into the BSI Construction segment, the role expanded from individual technical contributor to leading six engineering teams simultaneously — three onshore, three offshore — within a SAFe Agile delivery framework. The mandate was not just to build software but to build the organization that builds software.
BSI Construction is Travelers’ commercial construction insurance business segment. The systems that support it handle underwriting decisions, policy management, and risk assessment for a specialized and technically demanding insurance category. The engineering teams responsible for those systems needed leadership, architectural direction, and a flagship platform to anchor the segment’s modernization strategy.
Three Teams · US-Based
Core product and platform engineering, architecture and design, and client-facing application development
Three Teams · Global
Feature development, QA and test automation, and infrastructure and operations across multiple time zones
SAFe Agile
Scaled Agile Framework coordination across all six teams with synchronized release trains and shared program increments
Managing six teams across time zones and organizational layers requires a different discipline than managing one. The technical work does not stop — architectural decisions still need to be made and reviewed — but it becomes embedded in a broader practice of team health, stakeholder alignment, delivery rhythm, and cross-team dependency management. The role demanded both.
Underwriting Canvas
Underwriting Canvas was the flagship product of the BSI Construction engineering organization — the platform that underwriters used to evaluate, structure, and bind commercial construction insurance policies. Building it right meant designing a modern, cloud-native application on top of a data model that spanned decades of commercial insurance history.
Underwriting Canvas
A React single-page application backed by a Node.js microservices layer and deployed on AWS, Underwriting Canvas replaced fragmented legacy tooling with a unified underwriting workspace. The architecture was designed for the dual reality of enterprise insurance: the need for sophisticated, real-time user interactions on the front end, and the requirement to integrate with deeply entrenched backend systems at the data layer.
The platform included several supporting applications alongside the core Underwriting Canvas: an AFST (Agent Financial Summary Tool) for financial modeling within the underwriting workflow, an Electronic File Cabinet for policy document management, and a Globalization Pipeline that managed content localization across market-facing surfaces. Each was built as a discrete service within the same platform ecosystem rather than as a standalone system, ensuring that the underwriting workflow remained coherent end to end.
From PCF to AWS
The infrastructure inherited in Phase 2 was Pivotal Cloud Foundry — an enterprise PaaS that had served the Travelers engineering organization through the previous decade but was increasingly difficult to justify against the capabilities and economics of native AWS. The migration was not a flag-day cutover. It was a phased, hybrid-state transition that required the BSI Construction systems to operate across both environments simultaneously for an extended period.
Moving from PCF to AWS required re-thinking deployment pipelines, secrets management, networking topology, and monitoring strategy. Terraform provided the infrastructure-as-code layer that made the migration tractable: every resource definition was versioned, reviewable, and repeatable, eliminating the configuration drift that had accumulated in the PCF era.
Pivotal Cloud Foundry
An enterprise PaaS with strong abstractions but limited native cloud service integration, Jenkins-based CI/CD, and IBM UrbanCode Deploy for release management. Functional but constrained.
- PCF for application hosting
- Jenkins for continuous integration
- IBM UrbanCode Deploy for releases
- Manual secrets management
- Limited observability tooling
AWS Native
A cloud-native architecture on AWS with managed infrastructure, automated secrets rotation, and integrated observability — giving the engineering teams the operational leverage that PCF had always withheld.
- AWS CloudFront, S3, Lambda, DynamoDB
- Terraform for infrastructure as code
- HashiCorp Vault for secrets management
- Datadog & Grafana for observability
- Taiko/Gauge for end-to-end test automation
The hybrid migration period was intentionally managed rather than rushed. Teams continued shipping product features throughout the transition. The migration was treated as infrastructure work that ran in parallel with product delivery rather than as a prerequisite that blocked it. That decision — to migrate while still delivering — required strong cross-team coordination and a shared understanding of which systems were in which state at any given moment.
Six Years, Two Eras
The technology environment at Travelers evolved significantly across the six-year engagement — partly driven by industry-wide trends and partly by deliberate modernization decisions made within the BSI Construction segment. The two phases had meaningfully different stacks.
Phase 1
Enterprise Legacy + Emerging React
A mixed-generation environment with PCF as the deployment platform, mainframe data layers, and the AngularJS-to-React migration already in progress. The consulting engagement operated within and around existing enterprise constraints rather than replacing them outright.
Phase 2
Cloud-Native AWS Platform
A purpose-built cloud-native architecture for the BSI Construction segment, migrated from PCF and built on AWS managed services. Infrastructure as code, automated testing, secrets management, and observability treated as first-class engineering concerns from the start.
Stack & Craft
- React / TypeScript
- AngularJS (migrated)
- Component Architecture
- SPA Patterns
- Node.js / Express
- Microservices
- REST APIs
- Messaging Proxy
- CloudFront · S3
- Lambda · DynamoDB
- EventBridge
- IAM / VPC
- DynamoDB
- SQL Server · DB2
- IBM Mainframe
- Redis
- Terraform (IaC)
- PCF (Phase 1)
- HashiCorp Vault
- Jenkins / UrbanCode
- Taiko / Gauge
- Datadog · Grafana
- SAFe Agile
- CI/CD Pipelines