An open-source, composable commerce architecture

In this multi-part series article, we present Radixia Maca, our open-source solution for AI composable commerce.

Modern brands leverage e-commerce not just as a sales channel—it's a primary digital touchpoint that defines how customers experience, engage with, and remember you. It's where storytelling meets transaction, where brand identity is expressed through every click, search, and scroll. In this context, putting products online is no longer enough. To meet customer expectations, brands need flexible, intelligent, and cost-efficient commerce experiences that feel seamless across devices and moments. Whether you're launching a niche product line or managing global merchandise, the ability to move quickly, iterate frequently, and minimize operational overhead is essential. Today, composable and scalable e-commerce is no longer a nice-to-have—it's foundational to how modern brands build meaningful digital relationships.

As a case study to showcase our solution, we focus on ServerlessDays, a solution for merchandising—T-shirts, hats, keychains, and stickers—that wouldn't require a whole DevOps team to maintain.AWS Bedrock Agents, Commerce Layer, and Strapi CMS—all stitched together with AWS CDK, Lambda, and Fargate.

This isn't just a demo. It's a practical, production-grade reference implementation for composable commerce done right. It demonstrates how to create an intelligent, API-first e-commerce experience that serves as a blueprint for any team seeking to modernize digital commerce with minimal operational overhead and maximum scalability.

Why does this matter? Because too many e-commerce implementations are monolithic, fragile, or operationally burdensome. With this architecture, a modular, cloud-native stack.

In this multi-part article, we'll walk you through the whole architecture, from infrastructure-as-code to Bedrock-powered natural language product search. You'll see how we use:

• AWS Bedrock Agents and MCP servers to bring semantic search to commerce
• Commerce Layer to handle inventory, pricing, and order orchestration
• Strapi CMS for managing content and product metadata in a fully headless fashion
• A serverless infrastructure based on Lambda, Fargate, and CDK for elasticity and maintainability

Project Overview

The goal of this project is to create a modern, scalable, and easy-to-maintain e-commerce platform for selling ServerlessDay merchandise. The solution will leverage serverless technologies to minimize operational overhead and provide a flexible, cost-effective architecture. Key features of our implementation include:

1. Semantic Product Search: Using AWS Bedrock Agents to enable natural language search capabilities
2. Headless CMS: Using Strapi for content management
3. E-commerce API: Using Commerce Layer for product, inventory, and order management
4. Serverless Architecture: Using AWS Lambda and Fargate for compute resources
5. Infrastructure as Code: Using AWS CDK for infrastructure provisioning

Architecture Overview

Our serverless e-commerce architecture consists of several key components:

Frontend Layer

• Static Website: Hosted on Amazon S3 and distributed via CloudFront
• User Interface: Responsive design for both desktop and mobile devices

API Layer

• API Gateway: Exposes REST APIs for the frontend
• Lambda Functions: Process API requests and implement business logic
• Bedrock Agents: Provide semantic search capabilities

Content Management Layer

• Strapi CMS: Manages product content, descriptions, and images
• Fargate Service: Hosts the Strapi CMS application
• S3 Storage: Stores media files uploaded to Strapi

E-commerce Layer

• Commerce Layer: Manages product catalog, inventory, prices, and orders
• Integration Lambda: Synchronizes data between Strapi and Commerce Layer
• Order Processing Lambda: Handles order creation and fulfillment

Data Storage Layer

• DynamoDB: Stores product, order, and inventory data
• Amazon RDS: Database for Strapi CMS
• S3 Buckets: Store static assets and media files

Infrastructure Layer

• AWS CDK: Defines and provisions all infrastructure resources
• CloudWatch: Monitors application performance and logs
• IAM: Manages security and access control

Here's a visual representation of our architecture:

┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│   Frontend      │     │   API Layer     │     │  Content Mgmt   │
│                 │     │                 │     │                 │
│  - S3 Website   │────▶│  - API Gateway  │◀───▶│  - Strapi CMS   │
│  - CloudFront   │     │  - Lambda       │     │  - Fargate      │
└─────────────────┘     │  - Bedrock      │     └────────┬────────┘
                        └────────┬────────┘              │
                                 │                        │
                        ┌────────▼────────┐     ┌─────────▼───────┐
                        │  E-commerce     │     │  Data Storage   │
                        │                 │     │                 │
                        │ - Commerce Layer│◀───▶│  - DynamoDB     │
                        │ - Lambda        │     │  - RDS          │
                        └─────────────────┘     │  - S3 Buckets   │
                                                └─────────────────┘

Key Technologies

Let's take a closer look at the key technologies we'll be using:

AWS Bedrock and MCP Servers

AWS Bedrock is a fully managed service that provides access to foundation models (FMs) from leading AI companies. We'll use Bedrock Agents to implement semantic product search, allowing users to find products using natural language queries. The Model Context Protocol (MCP) server serves as a connector between Bedrock Agents and our data sources, allowing agents to access product information from the Commerce Layer and Strapi.

Commerce Layer

Commerce Layer is a headless commerce platform that provides APIs for managing all aspects of an e-commerce store. It handles product catalogs, inventory, prices, shopping carts, checkout, and orders, while leaving content management and presentation to other systems.

Strapi CMS

Strapi is an open-source headless CMS that allows us to manage product content, descriptions, and images. It provides a user-friendly admin interface and exposes content through REST and GraphQL APIs.

AWS CDK

AWS Cloud Development Kit (CDK) is an infrastructure-as-code tool that allows us to define cloud resources using familiar programming languages. We'll use TypeScript to define our entire infrastructure, making it easy to version, test, and deploy.

Prerequisites

Before we begin, make sure you have the following prerequisites:

1. AWS Account: You'll need an AWS account with appropriate permissions
2. Node.js and npm: Install Node.js (version 14 or later) and npm
3. AWS CDK: Install the AWS CDK CLI (npm install -g aws-cdk)
4. Docker: Install Docker for local development and testing
5. Commerce Layer Account: Sign up for a Commerce Layer account
6. AWS CLI: Install and configure the AWS CLI

Development Environment Setup

Let's set up our development environment:

# Create a new directory for our project
mkdir serverless-ecommerce
cd serverless-ecommerce

# Initialize a new npm project
npm init -y

# Install AWS CDK
npm install -g aws-cdk
npm install aws-cdk-lib constructs

# Initialize a new CDK project
cdk init app --language typescript

# Install additional dependencies
npm install @aws-cdk/aws-lambda-nodejs @aws-cdk/aws-apigateway @aws-cdk/aws-dynamodb @aws-cdk/aws-s3 @aws-cdk/aws-cloudfront @aws-cdk/aws-ecs @aws-cdk/aws-rds @aws-cdk/aws-secretsmanager

Now that we have set up our development environment, we're ready to start implementing our serverless e-commerce solution. In the next section, we'll dive into the implementation of the AWS CDK infrastructure.

Project Structure

Our project will have the following structure:

serverless-ecommerce/
├── cdk-app/                  # CDK infrastructure code
│   ├── bin/                  # CDK entry point
│   └── lib/                  # CDK constructs
├── lambda/                   # Lambda functions
│   ├── semantic-search/      # Semantic search Lambda
│   ├── strapi-cl-sync/       # Strapi-Commerce Layer sync Lambda
│   ├── order-processor/      # Order processing Lambda
│   └── inventory-manager/    # Inventory management Lambda
├── docker/                   # Docker configurations
│   ├── mcp-server/           # MCP server Docker configuration
│   └── strapi-cms/           # Strapi CMS Docker configuration
└── frontend/                 # Frontend application

This project is more than an exercise in using the latest tools—it's the foundation of Radixia Maca, our purpose-built solution for composable commerce. Designed to help brands deliver intelligent, adaptable digital experiences with minimal operational overhead, Radixia Maca combines best-in-class services within a fully serverless, modular architecture. In the chapters ahead, we'll break down how Radixia Maca is engineered—from semantic product discovery powered by AWS Bedrock Agents to content and commerce orchestration via Strapi and Commerce Layer, all deployed with scalable precision using AWS. u're building for flexibility, speed, or future-proof architecture, Radixia Maca offers a blueprint for modern e-commerce that's as powerful as it's practical.

In the next chapter, we will focus on setting up and configuring Infrastructure as Code.