Principal Engineer Resume - Cloud & Distributed Systems

Summary

Principal Engineer with 30+ years of experience architecting, building, and scaling production systems across cloud, distributed, and event-driven environments. I define technical direction, design end-to-end architectures, and deliver systems that are reliable, observable, and built to last. Equally comfortable writing code, designing APIs, reviewing architectures, or debugging complex failures in production. Known for clear technical judgment, deep hands-on expertise, and the ability to turn ambiguous problems into well-engineered solutions.

Core Strengths

Architecture & system design for distributed, cloud-native platforms
Hands-on engineering across Python, Go, C#, TypeScript, and Node.js
AWS expertise: Fargate, Lambda, DynamoDB, Kinesis, EventBridge, SQS/ SNS
Technical ownership: standards, code quality, observability, reliability
Cross-functional leadership with clear technical direction
Execution under pressure; trusted to deliver critical systems

Leadership

Define architecture and technical strategy across teams
Hands-on problem solver for the hardest engineering challenges
Mentor engineers and elevate team technical standards
Balance long-term architecture with immediate delivery needs
Communicate clearly across engineering, product, and leadership

Experience

Principal-Level Senior Software Engineer, Experian Consumer Services2013 - Present

Consumer Credit & Financial Wellness Platform - A large-scale platform that provides secure access to credit reports, credit scores, identity monitoring, and Smart Money digital banking. Designed for multi-channel delivery across web and mobile, supporting millions of users with high availability, strong security, and real-time financial insights. (Python, React, AWS, Linux, C#, TypeScript, Go, MySQL, PHP, REST)

Architect core platform services on AWS using Fargate, Lambda, API Gateway, DynamoDB, Kinesis, EventBridge, and SQS/SNS
Design and implement distributed systems for high-volume, business-critical workloads
Build deep observability into services using Datadog, enabling faster incident detection and resolution
Lead cross-team architectural direction, technical standards, and long-term platform strategy
Mentor engineers and guide complex technical decisions across multiple teams
Recognized with Platinum Aspire, EMF Hero - Above & Beyond, and multiple Spot Awards for technical leadership and impact

Software Development Lead, Experian CheetahMail2005 - 2013

Enterprise Email Marketing Platform - High-throughput system powering targeted campaigns for major global brands, supporting billions of emails per day with advanced segmentation, tracking, and reporting. (Python, Linux, Oracle, C#, TypeScript, Perl, REST)

Led engineering teams delivering large-scale email and marketing systems
Designed backend services, APIs, and high-throughput data pipelines
Awarded the Pinnacle Award for engineering excellence

Software Engineer, AirIQ (formerly Aircept)2005

Real-Time GPS Asset Tracking Platform - System supporting continuous vehicle and equipment tracking with GPS monitoring, telemetry, alerts, and location intelligence. (C#, TypeScript, SQL Server, ASP.NET, REST)

Built real-time GPS tracking and telemetry systems
Designed backend services and data flows for high-frequency location data

Web Developer, RazorGator2003 - 2005

Yahoo! Tickets - Scalable ticketing platform enabling sellers to publish live event inventory across Yahoo!'s ecosystem, supporting high-traffic volume, flexible integrations, and reliable performance. (C#, TypeScript, SQL Server, PHP, REST, XML)

RazorGator Ticket Marketplace - B2B/B2C ticket marketplace supporting sports, concerts, theater, and travel packages, engineered for transactional reliability, multi-model commerce, and high-volume search and purchasing flows. (C#, TypeScript, SQL Server, MySQL, ASP.NET, REST, XML)

Built full-stack e-commerce systems supporting high-traffic ticketing operations
Delivered features end-to-end across front-end, backend, and database layers

Independent Professional, Self Employed1995 - Present

GigaOm Publishing Platform - Custom publishing engine powering a multi-channel tech media site with scalable content delivery, high engagement, and flexible editorial workflows. (PHP, TypeScript, MySQL, REST)

Rainbow Guitars E-Commerce Platform - Rainbow Guitars E-Commerce Platform - Online retail system supporting rich product detail, diverse inventory, and a smooth purchasing experience for a long-standing music retailer. (C#, TypeScript, SQL Server, ASP.NET, REST)

Fortini Home Artisan Retail Platform - Lifestyle-focused retail system showcasing handcrafted products with rich visual storytelling and a premium shopping experience. (C#, TypeScript, SQL Server, ASP.NET, REST)

Exhibit Transport Logistics Platform - Global logistics system supporting international shipping workflows, operational visibility, and seamless coordination for the trade show industry. (PHP, TypeScript, MySQL)

S&M Bikes Commerce Platform - Brand-driven commerce system showcasing high-performance BMX products with strong product management and customer engagement capabilities. (PHP, TypeScript, MySQL)

Clipper Corp Service Solutions Platform - Service-oriented system enabling tailored solutions, scalable delivery, and improved operational efficiency. (PHP, TypeScript, MySQL)

AnchorBlue E-Commerce Platform - Online retail platform supporting product discovery, merchandising, and seamless purchasing for a national youth clothing brand. (PHP, TypeScript, MySQL, REST)

WheelBuilder Custom Wheel Platform - Precision-driven product system supporting custom wheel configuration, accurate ordering, and high-quality product presentation. (PHP, TypeScript, MySQL, REST)

Pacifica Services Engineering Platform - Dynamic services system enabling consistent client engagement, scalable operations, and support for evolving industry needs. (PHP, TypeScript, MySQL)

Architect and deliver production-ready systems across diverse industries, from media and retail to logistics and engineering services
Provide deep engineering expertise, technical leadership, and end-to-end ownership across full-stack development
Design scalable architectures, data flows, and integration patterns for high-traffic and commerce-driven platforms
Collaborate directly with founders, executives, and cross-functional teams to translate business goals into technical solutions
Lead delivery of multiple concurrent projects while maintaining quality, performance, and long-term maintainability

Education

Master of Science, Software Engineering, California State University, Fullerton2005 - 2007

Outstanding Graduate Project Award

Bachelor of Engineering, Architecture, Petra Christian University1993 - 1997

Certifications

Advanced Studies, Data Science, Stanford University2015

Mining Massive Datasets - With Distinction
Machine Learning
Automata

Skills

Cloud & Infrastructure: AWS Fargate, Lambda, API Gateway, ALB, Route 53, S3, VPC
Event-Driven Systems: Kinesis, Firehose, EventBridge, SQS, SNS
Databases: DynamoDB, MySQL, Oracle, SQL Server
Languages: Python, Go (Golang), C#, PHP, TypeScript, Node.js
AI & Modern Tooling: AWS Bedrock
Observability: Datadog (APM, logs, metrics, dashboards)
Architecture: Distributed systems, microservices, event-driven design, serverless
DevOps: Docker, CI/CD, Git workflows
Front-End: React, HTML5, CSS

Testimonials

use std::time::{Duration, Instant}; struct Task { id: u32, label: &'static str, progress: f32, } impl Task { fn new(id: u32, label: &'static str) -> Self { Self { id, label, progress: 0.0 } } fn update(&mut self, dt: f32) { self.progress = (self.progress + dt * 0.1).min(1.0); } } struct Scheduler { tasks: Vec<Task>, last: Instant, } impl Scheduler { fn new() -> Self { Self { tasks: vec![], last: Instant::now() } } fn add(&mut self, label: &'static str) { let id = self.tasks.len() as u32; self.tasks.push(Task::new(id, label)); } fn tick(&mut self) { let dt = self.last.elapsed().as_secs_f32(); for t in &mut self.tasks { t.update(dt); } self.last = Instant::now(); } fn summary(&self) -> String { self.tasks .iter() .map(|t| format!("{}: {:.0}%", t.label, t.progress * 100.0)) .collect::<Vec<_>>() .join(", ") } } fn compute_load(v: &[u32]) -> u32 { v.iter().fold(0, |a, b| a.wrapping_add(b.wrapping_mul(3))) } fn generate_series(n: usize) -> Vec<u32> { let mut x = 1u32; let mut out = Vec::with_capacity(n); for _ in 0..n { x = x.rotate_left(3) ^ 0x9e37; out.push(x); } out } struct Logger { entries: Vec<String>, } impl Logger { fn new() -> Self { Self { entries: vec![] } } fn log(&mut self, msg: String) { self.entries.push(msg); } fn flush(&self) { for e in &self.entries { println!("[log] {}", e); } } } fn normalize(v: &mut [f32]) { let sum: f32 = v.iter().sum(); if sum > 0.0 { for x in v { *x /= sum; } } } fn smooth(v: &mut [f32]) { if v.len() < 3 { return; } let mut prev = v[0]; for i in 1..v.len() - 1 { let current = v[i]; let next = v[i + 1]; v[i] = (prev + current + next) / 3.0; prev = current; } } struct Analyzer { buffer: Vec<f32>, } impl Analyzer { fn new() -> Self { Self { buffer: vec![0.0; 16] } } fn sample(&mut self, x: f32) { self.buffer.rotate_left(1); self.buffer[self.buffer.len() - 1] = x; } fn process(&mut self) { smooth(&mut self.buffer); normalize(&mut self.buffer); } fn score(&self) -> f32 { self.buffer.iter().enumerate().map(|(i, v)| *v * (i as f32)).sum() } } fn checksum(v: &[u8]) -> u32 { v.iter().fold(0u32, |a, b| a.wrapping_add((*b as u32).wrapping_mul(17))) } fn build_packet(id: u16, payload: &[u8]) -> Vec<u8> { let mut out = vec![(id >> 8) as u8, (id & 0xFF) as u8]; out.extend_from_slice(payload); let sum = checksum(payload); out.extend_from_slice(&sum.to_be_bytes()); out } fn simulate_io(logger: &mut Logger) { let payload = [1, 2, 3, 4, 5, 6]; let packet = build_packet(42, &payload); logger.log(format!("packet {} bytes", packet.len())); } fn main() { let mut sched = Scheduler::new(); let mut logger = Logger::new(); let mut analyzer = Analyzer::new(); sched.add("parse"); sched.add("compile"); sched.add("optimize"); sched.add("emit"); let series = generate_series(32); let load = compute_load(&series); for _ in 0..10 { sched.tick(); analyzer.sample(sched.tasks.len() as f32); analyzer.process(); } simulate_io(&mut logger); println!("load: {}", load); println!("tasks: {}", sched.summary()); println!("score: {:.2}", analyzer.score()); logger.flush(); }