500+ projects · 32categories · open to everyone

You build it. We bring the rest.

You have the ideas, the talent, and maybe some AI tokens to burn. What you don’t have is a storefront, servers, a support desk, or an easy way to reach customers — and that is exactly what WBSP brings. Developers and testers turn skill into software that ships, gets supported, and sells.

Build for reward or build for reputation. Either way, the work you do here is visible, credited, and yours.

What should I build?

Why build here

Why developers and testers build on WBSP

You bring the skill. WBSP brings the storefront, the partners, the customers, and the credit — the things that usually stop good software from ever reaching anyone.

Store, hosting & support — sorted

You have the ideas and the skill, but no storefront, no servers, and nobody to support what you make. WBSP brings the marketplace, hosting providers, and support partners, so you can just build.

Build a name

Every contribution is tracked and credited. Make your work visible and let a growing trail of shipped software speak for you — fame, glory, and reputation included.

Proof you can point to

There is no better portfolio than real, running products people actually use. Turn what you can do into evidence anyone can see.

Find your customers

Specialised software finds specialised buyers. Put your work where the people who need it — and the people who need your skills — are already looking.

Team up

Find developers, testers, and partners to form a team or an alliance — or lend your skills to a project that needs exactly what you bring.

Testers, this is for you too

You don't have to write the code to be essential. Test real products, file clear, reproducible issues, earn credit, and build the trust owners look for.

The model

Software that grows through derivation

derivation-tree · crm-coreexample

CRM Core#41

└─CRM for Real Estate+12

└─Commercial Property+5

└─Property Managementnew

└─CRM for Healthcare+8

└─Dental Practicesnew

CoreVariantJust forked

It starts with a core project. A developer creates a variant, adding their domain expertise, say, adapting a CRM for real estate. Another takes that variant and specialises it further for commercial property. Each layer builds on the work below it.

“500+ projects become thousands of specialised applications, each one standing on the shoulders of the developers who came before.”

When a variant improves, those changes can flow back upstream. When the core improves, every variant downstream benefits. The full derivation tree is tracked, who built what, who built on whom, so credit and revenue follow the chain. The chain never forgets.

Four steps

How it works

Discover

Browse 500+ projects across 32 categories. Find one that matches your expertise or interests.

Create a variant

Fork any project, or any variant of one, to make your own version. Specialise it for an industry, audience, or use case.

Contribute back

Submit improvements upstream. Your changes pass quality gates, automated tests, code review, validation, before merging.

Earn attribution

Every contribution is tracked through the derivation tree. When others build on your work, you earn credit and revenue.

Under the hood

The secret sauce

Customising enterprise software has been painful since the dawn of IT. A company buys a product that is an eighty percent fit, spends a million dollars or more tailoring it to their exact needs, and then can never move to a new version, because every customisation would have to be rebuilt.

So customers stay stuck on old versions, and vendors are left supporting a long line of them. The more customers a vendor has, the worse the problem becomes.

The magic of WBSP Layers is solving this: new core features can be merged into customised code, and useful customisations can be merged back into the core product.

Tools like git let code be forked, and the forks merged back together, but they struggle with major changes or overlapping updates, often requiring slow, manual effort.

The problem is that git does not understand what the code does, or what a new change is trying to achieve. It merges lines of text, with no idea what those lines mean.

With WBSP, applications are AI-native, written entirely from plain human-language descriptions of what is required. As the code is developed, the AI keeps a log of why every line was written, and those explanations live inside the code itself. When it comes time to merge different versions, WBSP has everything it needs to update the software intelligently.

with-intent · invoice-totalsAI-native

// derivation: invoice-totals

function applyTax(line) {

// why: EU B2B invoices must show net,

// tax and gross separately (spec 4.2)

const net = line.qty * line.unitPrice;

const tax = net * line.taxRate;

return { net, tax, gross: net + tax };

}

Every line carries its reason. The merge understands both.

Who it’s for

There’s a role for you

You don’t have to write code to seed a derivation tree, or to profit from one.

Developers

Build on what others have started

Pick any project or variant as a starting point. Add your domain expertise, specialise for a new market, or improve the core. Earn attribution and revenue when others build on your variant.

Start building→

Spec Writers & Analysts

Shape what gets built

Your industry expertise defines the specifications developers turn into real software. No coding required, your domain knowledge seeds the derivation tree.

Define a project→

Enterprise & Buyers

Find a variant, or commission one

Browse specialised variants across every industry. Find one close to what you need, or commission a new variant built on a proven base. No vendor lock-in, the code is yours.

Explore solutions→

Marketers & Sales