Flamingo Commerce is an open-source, MIT-licensed e-commerce framework written in Go and built on top of the Flamingo web framework, intended for teams that build headless commerce portals and connect them to external services through their own adapters.

What it is

Flamingo Commerce is a toolkit for building fast and flexible commerce experience applications in Go. It lives in the Flamingo ecosystem and is distributed as a set of e-commerce modules, each of which is a separate bounded context containing its own domain, application, and interface logic. The major modules are product, cart, category, price, search, and checkout. The framework applies domain-driven design together with a ports and adapters architecture, which means the domain logic does not depend on the technical details of any particular backend service. Each module also provides GraphQL support that applications can expose directly.

The concrete problem it solves is monolithic e-commerce architecture. The project is explicitly positioned as a way to break a monolith apart so that commerce can scale and remain maintainable, and as a foundation for headless commerce solutions. Because the domain is separated from the technical implementation by ports and adapters, an application can be wired to any API or microservice through a custom adapter rather than being locked to one commerce backend. It also targets real-time commerce: the stated design goal is to avoid relying on frontend caching, so showing every customer an individual, personalized experience is not a problem.

Key capabilities

• Commerce modules for typical e-commerce domains: price, product, category, cart, search, and checkout, each a separated bounded context with domain, application, and interface logic.
• price module provides value objects for prices and charges, supporting calculations, rounding, and splitting, plus multiple prices including loyalty prices.
• cart module provides a cart domain model that supports multi delivery and multiple payment transactions.
• product module provides domain models and interface logic for handling different product types.
• GraphQL support in each module, demonstrated through the GraphQL console on the online demoshop.
• Ports and adapters architecture so every module can be connected to your own adapter for any API or microservice.
• Fake adapters that supply test data, allowing application and domain tests to run without external dependencies.

Who uses it and how

• Teams breaking a monolithic e-commerce architecture into services, using adapters to reach each service while keeping the domain logic intact.
• Teams building headless commerce, where frontend development is decoupled from the backend for frontend and any frontend technology can be used.
• Teams running microservice architectures, where the adapter concept and the framework's resilience concepts are used to connect to other services safely.
• Teams that need personalized, real-time commerce experiences without caching rendered pages per customer.
• Teams that want to test commerce logic in CI without standing up external systems, by substituting fake adapters for real ones.

Getting started

The README points to the Flamingo documentation getting-started guide at docs.flamingo.me as the entry point, and a running demoshop using the standalone adapters is available at https://demoshop.flamingo.me, including its GraphQL console. No package install command or Docker image is named in the provided README excerpt.

How it compares

No list of paid products that this project replaces is provided in the facts, and no comparable tools are named either. It sits on top of the Flamingo framework itself, so it is best understood as a commerce layer for Flamingo applications rather than a standalone product; on that basis it stands alone in this registry.

When to use it — and when not to

A self-hoster must operate a Go service built on the Flamingo framework and write or maintain adapters to the backend systems the domain connects to; the facts do not name a required database, object storage, or SMTP dependency, so those remain the adopter's choice. It is a poor fit for teams that want a turnkey hosted shop, since the project supplies framework modules rather than a finished application. The README excerpt is largely a pointer to external documentation and does not include install commands, so setup effort should be assessed against the Flamingo docs before committing.

import (
  "flamingo.me/flamingo-commerce/v3/product"
)

// main is our entry point
func main() {

	flamingo.App([]dingo.Module{
	    ...
		//flamingo-commerce modules
		new(product.Module),
		
	}, nil)
}

go get flamingo.me/flamingo-commerce/v3