In production since 2018

Software that outlives the app it was written for.

ncubo builds distributed systems across mobile clients, services, clusters, data centers and independent participants — and a domain technology of its own that keeps them coherent when the deployment, the client or the topology changes.

Executable comparison

The same invoice, built two ways.

A conventional .NET invoice flow, and the same domain enacted as a Puppeteer Puppet. Same products, same amounts, same invoice — different architectural center.

Conventional implementation

Application owns the flow

One application flow coordinates domain behavior, authorization, persistence and response.

Puppet implementation

Domain owns the act

The Puppet decides the validity and consequences of the domain act. Infrastructure remains at the boundary.

Counted in the domainConventionalPuppet
Files in the domain225
I/O calls inside the flow50
Output formats in the domainweb framework dependency0

Counted in the repository. An existence proof that the separation is buildable — not a performance or cost evaluation.

  • Not the invoice.
  • Not the values.
  • Not the business outcome.

What changed was the architectural authority: who was allowed to validate, persist, transport and render the act.

Our model

Projects end.
Domains continue.

ncubo is organized around reusable domain assets rather than isolated deliveries.

Every implementation adds knowledge, architecture and validated technology to the same underlying capability. The next system does not start from zero.

Each delivery serves the present. Each domain strengthens the future.

returns new value to the domain assetIMPLEMENTATION 01Domain knowledgeIMPLEMENTATION 02Reusable architectureIMPLEMENTATION 03Validated capabilityDOMAIN ASSETKnowledgeArchitectureReusable systemsValidationNEXT IMPLEMENTATIONstarts enriched, not from zero
A domain asset developed at ncubo

Puppeteer

Puppeteer emerged from our work on systems that must preserve identity, causality and authority across participants, machines and changing topologies.

It is now a reusable architecture for building shared, continuous and coordinated systems — the same architecture the comparison above puts side by side with a conventional implementation.

Distributed engineering

From mobile clients to clusters, data centers and peer-to-peer systems.

We build systems whose behavior must remain coherent across applications, services, machines and independent participants. Some systems coordinate through a stable center. Others distribute authority between servers, data centers or peers. We design for both.

EVENTS · DATA · OBSERVABILITY · REPORTINGMOBILE AND WEB CLIENTSSERVICES AND DOMAIN ACTORSDISTRIBUTED RUNTIMEDATA CENTER AServices · StateDATA CENTER BServices · StateCOORDINATED STATESERVER COORDINATIONPEER-TO-PEER PARTICIPANTSNo permanent centerONE SYSTEM · MANY TOPOLOGIES

Centralized when appropriate. Decentralized when required. Coherent in either topology.

  • Shared organizational state
  • Context-aware approvals
  • Privacy-preserving coordination
  • Event-driven operations
Technology by architectural responsibility
Product
  • Flutter
  • iOS
  • Android
  • Web
Services
  • C#
  • .NET
  • Linux
  • Microservices
  • Actors
  • PuppeteerDeveloped at ncubo
Runtime
  • Kubernetes
  • Containers
  • Clusters
Distribution
  • Server-to-server
  • Multi-data-center
  • Peer-to-peer

Central servers when appropriate · Peer-to-peer when required

Data and operations
  • Kafka
  • SQL
  • Distributed databases
  • Reporting
  • Observability

Start a technical conversation.

Whether you are evaluating a capability, planning a distributed system or considering a technical partnership — we would like to understand what you are building.

Start a Conversation