Developers, we have a problem:
The building blocks of code, while infinitely flexible, are too damn small.
On the flip side, while ready-made “no-code” solutions simplify and save time, they're way too rigid for developers.
There is a better way:

Build with

Writing software still feels like banging rocks together.

In the beginning, we punched ones and zeros – into cards. Some might celebrate how far our tools have come, but it’s just not enough.

We’re burning cycles on solved problems, reimplementing essentials like authorization, notifications, ecommerce, feature flagging, and recurring billing – none of which are unique to our applications. There are hundreds of features like these that we are forced to build over and over again.

We’re taking on a lot of risk through our naive implementations of these domain-layer features. Rolling our own (how hard could it be?) opens the door to introducing costly bugs, and adds the burden of long-term maintenance.

It’s near-impossible for one developer to build every essential feature in-house – and do it well. As we add complexity to our applications the team must expand in expertise and capacity dramatically increasing cost.

Does it have to be this hard?

Code should unlock our creative superpowers.

To achieve flow and focus on what truly matters, we need off-the-shelf building blocks that snap together at the right level of abstraction.

The most impactful code that we write within our applications is the implementation of our core value proposition. We dream of a world where we can focus on our unique and opinionated features without the laborious task of building scaffolding and various underpinnings that, while necessary, should be built by someone else.

When we reach for a solution, what we really want is to:

  • Speed up development
  • Improve product quality
  • Reduce code complexity

Yes-code tools give us superpowers.

Yes-code tools make building software feel like magic.

Designed for developers with speed and flexibility in mind, Yes-code tools deliver batteries-included solutions to domain-layer problems so we can focus on the code that matters in our applications.

The Yes-code Pattern:

Every application has dependencies. Make them your strength rather than weakness by building with tools that follow the Yes-code Pattern.


The core of what makes a Yes-code tool.

  1. Operate from within the codebase.
  2. Solve a discrete, domain-layer problem.
  3. Provide an administration and control plane.
  4. Expose a stable collection of remixable primitives.
  5. Assemble customizable kits for the most common use cases.
  6. Make the first-run experience plug-and-play.


Best practices for Yes-code tools.

  • Teach users about the domain, edge cases, and compliance.
  • Extract opinionated ideas and insights from production systems.
  • Embrace iterative configuration and deployment.
  • Include disposable sandbox environments.
  • Expose detailed audit logs for validation and testing.
  • Architect for robustness and reliability at scale.
  • Provide quality documentation and responsive support.


Important decisions for Yes-code tools.

  • Build to be language- and platform- agnostic.
  • Allow developers to use their preferred tools.
  • Rely on trusted infrastructure and be transparent about it.
  • Release source code for SDKs, formats, and interfaces as open source.

Stay in the loop.

Here’s what you can expect:

  • Hear about new Yes-code tools.
  • Stories from the innovators behind popular Yes-code tools.
  • Get inspiration from developers using yes-code tools in production.

We want to hear from you.

Did we miss something? Do you know someone we should meet?

Send us a note at [email protected] 💌

Yes-code logo
© Copyright 2023 –