Portfolio

Challenge

A retail team needed associates to apply loyalty “marks,” capture cart fields, and follow up after purchase inside Shopify POS, without slowing the line or relying on back-office workarounds.

Solution

POS tiles, modals, and Lambdas so loyalty marks and cart fields lived in the cashier flow with Admin configuration for product rules.

1. Built POS UI extensions for home tiles, modals, line-item actions, and post-purchase blocks so the flow lived where cashiers already worked.
2. Added an Admin link extension on product details so merchandisers could configure product point rules from Admin.
3. Implemented a supporting Lambda service for mark calculations and persistence the POS UI could call during a sale.
4. Provisioned the AWS footing with Terraform and CodeBuild specs so POS app deploys stayed repeatable across environments.

Trade-offs

• Chose POS extensions over a separate loyalty tablet to keep one device in the lane.

Challenge

A B2B operation needed external order payloads turned into accurate Shopify B2B orders, including company locations, catalogs, and price lists, without silent failures or duplicate chaos.

Solution

SQS-triggered Lambda with Zod validation, company/location enrichment, Shopify GraphQL create/reconcile, and response queues for visible failures.

1. Designed an SQS-triggered Lambda that validates each record with zod schemas and returns batch item failures the AWS way.
2. Separated concerns into processors, repositories (Prisma/Postgres), Shopify API clients, and mappers so order rules stayed testable.
3. Resolved company location and catalog pricing before mapping the payload into Shopify GraphQL order input.
4. On conflicts, updated metafields and cancelled the prior Shopify order before recreating, then published success or user-error results back to a response queue.

Trade-offs

• Preferred cancel-and-recreate on conflicts over partial silent updates so order truth stayed auditable.

Architecture

Challenge

A wholesale-style merchant needed checkout to enforce credit limits and capture delivery dates, rules that native Shopify checkout would not enforce on its own.

Solution

Checkout validation Functions plus delivery-date UI so credit and delivery rules blocked bad orders before payment.

1. Implemented a cart/checkout validation Function that blocked progress when an order would exceed allowed credit.
2. Added checkout UI extensions (and POS/delivery companions) so buyers and staff could pick delivery dates in-flow.
3. Wired theme/app extensions where storefront presentation needed delivery-date messaging.
4. Deployed the supporting Shopify apps and AWS services with Terraform so validation and delivery tooling stayed environment-consistent.

Trade-offs

• Enforced rules at checkout (buyer friction) instead of after-order cleanup (ops cost).

Challenge

The business needed customers to book classes on the storefront and have checkout reject invalid or unavailable dates before payment.

Solution

Theme booking UX with a checkout validator that can block progress when dates are invalid.

1. Shipped a theme app extension for the class-booking experience on the storefront.
2. Added a checkout UI extension with API and network access to validate selected dates against live availability rules.
3. Enabled block_progress so checkout could not continue when validation failed.
4. Backed the product with ECS/Terraform hosting and CI buildspecs for repeatable app releases.

Trade-offs

• Used block_progress for safety over soft warnings that buyers ignored.

Challenge

Store teams needed cashiers to override or apply special pricing during a sale, custom price taps and automatic discounts by day, without leaving POS or memorizing back-office discount IDs.

Solution

POS price-tap and date-based discount extensions with Remix/Prisma multi-store configs and Dockerized deploys.

1. Built POS home tile/modal extensions for a “price tapper” workflow so associates could apply custom prices on eligible products.
2. Added product-details and home POS extensions for automatic discounts driven by date rules.
3. Configured Remix apps with Prisma and multi-store Shopify app configs so each merchant environment could deploy cleanly.
4. Used Docker and CodeBuild (dev/prod) so POS app updates followed the same pipeline as other commerce services.

Trade-offs

• POS-side overrides instead of only Admin discounts so cashiers could act without ticket latency.

Challenge

An institutional storefront needed checkout to prefill shipping address details so buyers were not retyping known address data on every order.

Solution

Checkout UI extension that prefills known shipping fields for institutional buyers.

1. Implemented a checkout UI extension targeted at the shipping-address experience.
2. Loaded the address context Shopify exposes to the extension and applied prefills where the business rules allowed.
3. Kept the app extension-only (no Admin home UI) so the footprint stayed small and focused on checkout.

Trade-offs

• Extension-only footprint over a full custom checkout rewrite.

Challenge

Teams were recreating VPC, ECS, Lambda, CI/CD, and DNS wiring per project, which made reviews slow and environments drift.

Solution

Shared Terraform modules composed into stage/prod roots with Terraform Cloud branch applies.

1. Extracted shared Terraform modules for networking, ECS services, Lambdas, pipelines, Route53, and security groups.
2. Composed environment roots (stage/prod) from those modules instead of copy-pasted resource blocks.
3. Connected Terraform Cloud so merges to stage/main applied the matching environment.
4. Documented module inputs/outputs so new services could plug in without reinventing IAM and networking.

Trade-offs

• Module abstraction cost upfront to stop per-project snowflake VPCs and IAM.

Architecture

Lessons learned

Why we chose this

• Modules + Terraform Cloud over copy-paste roots: reviews stay on diffs that matter.

Challenge

Several Shopify apps needed production hosting, but spinning unique stacks per app would explode cost and operational load.

Solution

One AWS footing with a Terraform app map: shared RDS, per-app ECR/ECS/ALB/DNS/pipelines.

1. Modeled apps as a Terraform map: each entry gets ECR, ECS service, ALB, Route53, and a CodePipeline/CodeBuild path.
2. Shared one RDS instance and artifact buckets across apps while keeping deploy units independent.
3. Standardized Docker buildspecs so imagedefinitions and container names followed a predictable naming scheme.
4. Kept dev and prod roots in parity so promotion meant config and image tags, not redesign.

Trade-offs

• Shared database for cost vs fully isolated DBs per app; mitigated with clear schema ownership.

Challenge

A large catalog rebrand required importing product data, submitting orders, and fulfilling at volume, work that would overwhelm a single monolith job.

Solution

Import, submit, and fulfillment services with Terraform ECR/container footing and selective manual Lambdas where event-driven deploy fit better.

1. Split the pipeline into import, submit, and fulfillment microservices with clear ownership of each stage.
2. Used Terraform to provision ECR and container footing; required images present before apply so deploys did not hang on empty repos.
3. Kept selected high-churn Lambdas (webhooks, bulk order processing, product handlers) outside Terraform apply where manual/event-driven deploy fit better.
4. Connected Shopify Admin apps where operators needed visibility into the rebrand workflow.

Trade-offs

• Split pipeline stages for scale vs operational simplicity of one job.

Challenge

The client needed a full commerce microservice suite without the cost and ops weight of a full VPC/ECS stack for every service.

Solution

Lightsail containers and database for a predictable cost profile across Shopify apps, auth, gateway, admin, and portal.

1. Chose AWS Lightsail Container Services plus Lightsail Database for fixed pricing and simpler networking.
2. Defined per-service containers (Shopify apps, delivery/ERP integrations, auth, API gateway, admin, portal) in Terraform.
3. Sized power/bundles per service so quieter apps stayed on micro while hotter APIs could scale up.
4. Exposed HTTPS endpoints per service while keeping database connectivity private to the Lightsail network.

Trade-offs

• Chose Lightsail over full VPC/ECS for cost predictability, accepting fewer networking knobs.

Challenge

A merchandise operation needed separate domains, users, locations, orders, business rules, plus POS, without freezing the whole platform for every change.

Solution

Gateway, users, locations, orders, and business services with a POS app and Terraform hosting.

1. Split APIs into gateway, users, locations, orders, and business microservices with independent deploy units.
2. Built a POS app on top of those services for in-store workflows.
3. Provisioned AWS hosting with Terraform and Docker/CodeBuild pipelines per service.
4. Used a Shopify Lambda companion where event hooks needed to bridge Admin/POS events into the domain APIs.

Trade-offs

• More deploy units for independent domain velocity vs a single API package.

Challenge

Production deploys were risky: a bad release could take the live Remix app down before anyone knew the new build was unhealthy.

Solution

Blue/green process slots with health checks before cutover and webhook-driven automation.

1. Introduced blue and green process slots so the new build could start beside production.
2. Required health checks on green before any traffic cutover.
3. Automated the ritual with deploy scripts and webhook/GitHub Action triggers.
4. Kept rollback as “return to the last known-good slot” instead of an emergency rebuild.

Trade-offs

• Brief double-capacity during cutover in exchange for safer rollbacks.

Architecture

Challenge

Order and catalog side effects (intake, dispatch, fulfillments, inventory sync, reports) needed to scale independently and fail without taking down the whole commerce stack.

Solution

Isolated Lambdas for intake, dispatch, fulfillments, sync, and reporting on EventBridge/SQS triggers.

1. Modeled each concern as its own Lambda (or small service) with a single job.
2. Used EventBridge schedules and queue triggers so work arrived as events, not tight coupling.
3. Applied OOP-friendly service layers inside each function so handlers stayed thin.
4. Deployed IAM, queues, and functions through shared Terraform modules for consistency.

Trade-offs

• More functions to observe vs one worker that could cascade failures.

Challenge

The team needed to watermark assets on demand from S3 without building a full media platform.

Solution

Small S3 + Sharp watermark API with health checks and env-driven bucket config.

1. Built a Node/Express service with a health endpoint and a watermark API.
2. Pulled source objects from S3, applied text or image watermarks with Sharp, and returned temporary outputs.
3. Configured region/bucket defaults through environment variables for simple deployment.

Trade-offs

• Focused watermark service over a full media platform.

Challenge

Catalog migrations kept turning into one-off scripts that were hard to rerun safely in prod.

Solution

Dockerized migration templates with CodeBuild promotion paths for catalog moves.

1. Created a reusable migration template with Docker packaging.
2. Added CodeBuild specs for dev and prod so the same container path promoted cleanly.
3. Structured the job so product/catalog transforms could be re-run with clearer inputs and logs.

Trade-offs

• Template reuse over one-off laptop scripts.

Challenge

The company needed a content-editable marketing site without forcing engineers to ship every copy change.

Solution

ApostropheCMS with documented deploy and media workflows for a small marketing team.

1. Implemented the site on ApostropheCMS with Node and MongoDB.
2. Set up editor workflows for pages and media.
3. Documented deployment caveats (favicon/social/media uploads) so launches did not miss manual asset steps.

Trade-offs

• CMS editability over a fully static site so non-engineers could ship copy.