Ideas2IT Led the .NET Migration Behind a Retail Platform's Full Exit From Azure and AWS to GCP

A retail platform's legacy .NET estate carried deep Azure and AWS lock-in across 70+ .NET applications in 275+ .NET projects across 7 repositories and 30+ cloud service dependencies. Ideas2IT led the phased removal of that lock-in ahead of the client's GCP consolidation deadline.

Client

Retail Tech Platform

Industry

E-commerce

Service

App Modernization

Cloud Migration

Engagement

Dedicated FDE model

Location

Australia

01 Challenge

The platform's .NET estate had sprawled to 275+ projects across 7 repositories, including 250+ WebForms apps, Classic ASP, and a VB-based legacy project, wired into 30+ Azure and AWS services under a hard deadline to exit both clouds entirely.

02 Solution

Ideas2IT sequenced the exit rather than rewriting it: discovery mapped every dependency first, a lift-and-shift rehosted VM and AppServices workloads onto GCP Compute Engine with no redesign, and a cloud-agnostic abstraction layer isolated the 30+ Azure and AWS services behind swappable GCP-native interfaces before each was replaced.

03 Outcome

Discovery closed with full visibility into the estate before a single dependency moved. Every VM and AppServices workload was rehosted, the Azure/AWS service dependencies were replaced with GCP-native equivalents, and the Functions and Lambdas were migrated, closing out Phase I on the client's GCP timeline.

Phase 01

Mapping every dependency before any code was touched

Discovery and dependency mapping:

Phase I comprised four sequential workstreams: discovery, rehosting, dependency decoupling, and serverless migration. Phase I's mandate was safe relocation, which meant knowing exactly what existed before moving it. Two engineers spent three weeks assessing architecture, runtime versions, and hosting requirements across 70+ .NET applications and 275+ .NET projects across 7 repositories, including 250+ WebForms applications, Classic ASP projects, and a VB-based legacy project needing manual conversion.

The team scanned the codebase for every Azure and AWS service occurrence, mapped triggers and bindings for the 20+ Azure Functions and AWS Lambdas, and traced integrations, endpoints, and authentication flows end to end, closing the phase with complete visibility into migration complexity.

This Phase Produced

  • Architecture and dependency assessment across 275+ .NET projects
  • Azure and AWS service dependency inventory
  • Trigger, binding, and runtime compatibility review
  • Service occurrence mapping across the codebase
  • Integration, endpoint, and authentication flow map
  • Environment configuration inventory

Phase 02

Rehosting first

Lift-and-shift rehosting: moving VM and AppServices workloads to GCP

VM to VM migration and AppServices migration both followed the same rule: rehost without a rebuild. The team provisioned GCP Compute Engine VMs with networking, security, and IIS prerequisites, then moved applications directly off Azure VMs and Azure AppServices onto that infrastructure.

Configurations, service URLs, connection strings, certificates, and secrets were updated in place rather than rewritten, keeping application logic untouched while the hosting layer changed underneath it. Smoke testing and performance validation closed each rehost before the next bucket started.

This Phase Produced

  • GCP Compute Engine VM provisioning with networking, security, and IIS prerequisites
  • Azure VM to GCP Compute Engine rehost
  • Azure AppServices to GCP Compute Engine VM rehost
  • Updated service URLs, connection strings, certificates, and secrets
  • Smoke and performance test validation for each rehosted workload

Phase 03

Standardizing on GCP without a big-bang rewrite

Removing cloud lock-in: a wrapper layer standing between 30+ Azure/AWS services and GCP

The largest bucket in Phase I targeted the 30+ Azure and AWS services wired directly into the application layer. Rather than replace each integration in place, the team built an abstraction and wrapper layer that isolated cloud-specific logic from the applications calling it, then mapped every dependency to its GCP-native equivalent behind that interface.

Existing integrations were replaced service by service, infrastructure was stood up and deployed in GCP, and unit and regression tests confirmed each dependency was fully removed before the next one was tackled.

This Phase Produced

  • Full inventory of 30+ Azure and AWS service dependencies
  • Cloud-agnostic abstraction layer for storage, messaging, secrets, data, and monitoring
  • GCP-native service implementations with shim adapters for phased cutover
  • Replaced integrations across the application codebase
  • GCP infrastructure provisioning for IAM, networking, and service accounts
  • Unit and regression test suite confirming dependency removal

Phase 04

One function migrated and validated before the next

Serverless migration: realigning 20+ Azure Functions and AWS Lambdas to GCP Cloud Functions

Every serverless workload moved one function at a time, validated against its dependent services before the next one started. Triggers were realigned to their GCP equivalents: HTTP stayed HTTP, Timer became Cloud Scheduler with Pub/Sub, Blob and S3 storage triggers moved to Cloud Storage, Service Bus, SNS, and SQS consolidated into Pub/Sub, and Event Grid became Eventarc.

Cloud-specific SDK bindings were stripped out in favor of explicit GCP SDK calls and structured logging, IAM service accounts with Workload Identity replaced legacy credentials, and handlers were rebuilt idempotent and retry-safe to prevent cascading failures across the platform.

This Phase Produced

  • Trigger realignment map (HTTP, Timer, Blob/S3, Service Bus/SNS/SQS, Event Grid to GCP equivalents)
  • 20+ Azure Functions and AWS Lambdas migrated to GCP Cloud Functions
  • IAM service accounts with Workload Identity
  • Idempotent, retry-safe function handlers
  • Minimum-instance configuration for latency-sensitive endpoints
  • Unit, integration, and trigger-based test suite

The Outcome

Four phases, One .NET team and a full exit from Azure and AWS delivered on the client's GCP timeline.

Category Outcome Description
Scale 275+ .NET projects, 70 apps Assessed, rehosted, and decoupled across all four phases of Phase I.
Dependency removal 30+ Azure/AWS services Cloud service dependencies replaced with GCP-native equivalents behind a cloud-agnostic abstraction layer.
Serverless migration 20+ Functions/Lambdas Realigned and moved to GCP Cloud Functions with trigger and binding remapping.
Milestone Rehosting completed VM and AppServices workloads rehosted to GCP Compute Engine with no redesign.
Milestone Dependency decoupling Application layer fully isolated from Azure/AWS-specific service logic.
The sequencing did the work here: discovery closed before a single dependency moved, rehosting closed before any service was rewritten, and the abstraction layer isolated 30+ Azure and AWS services one at a time rather than in a single cutover. That order is what made a hard GCP migration deadline achievable across 275+ projects without the redesign the client explicitly ruled out.