The CloudWinks framework

AI does the work. CloudWinks keeps the record.

CloudWinks is the dynamic AI backbone for apps of every kind, for business, community and personal use. Download the framework once. From then on, new apps and every change to them update automatically, with nothing to redeploy.

CloudWinks is an application framework for all kinds of software. An application is described in data — its screens, its fields, its menus, its tables — and the framework builds the working product from that description. Every application it builds shares the same shell, the same identity layer and the same pipeline.

Definitions-driven · A shared .NET service API · PostgreSQL data layer · Flutter client on web and phone

What it is

One framework underneath every application.

Most software grows into a collection of separate products that each need their own login, their own interface and their own maintenance. CloudWinks was built the other way around: a single framework holds the shared parts, and each application contributes only the definitions that make it different.

An application registry, not a bundle

The framework is the container. It registers the applications, holds their state, and serves their navigation. Applications are entries in that registry, which means one deployment can carry many products on one database server.

Metadata-driven interface

Every screen, field and menu is a row in the database, not a hand-coded page. The client asks the framework what to draw and renders it. Change the definition and the interface changes with it — for every user, everywhere.

One schema per application

Each application owns its schema inside a single PostgreSQL server, so data stays cleanly separated while operations, backups and reporting stay in one place. A shared identity base ties users and companies across every application.

Sign in once

Authentication is part of the framework, not an add-on. Sign-in goes through Firebase, with providers for Google, Facebook, LinkedIn and X configured at the framework level.

Modules that are already modelled

The platform applications carry the hard, unglamorous work: identity, files and media, notifications, reporting, messaging, integrations, workflow and scheduling. A new product starts from those definitions rather than from a blank page.

One pipeline, repeatable

A Python build, import and seed pipeline materialises an application from its definitions: schema first, then screens, then data. Rebuilding a clean environment is a command, not a project.

How it works

From a description to a running application

An application is specified as numbered definition folders and an application_setup.json that declares its name, its category and the hostnames it answers on. The pipeline does the rest, in a fixed order.

Build

Creates the schema, tables, functions, views and constraints for the application from its table definitions.

Import

Registers the application, then imports its controls, fields and menus so the framework knows how to draw it.

Seed

Loads the starting data, including the rows that must be tied to the application's own identifier.

Serve

The shared client opens the application, in a browser and on a phone, behind the one sign-in the framework provides.

The shape of the stack

Three languages, each doing the job it is good at: Dart and Flutter for the client that runs in a browser and on Android, a shared .NET service API as the gateway to the data, and Python for the build pipeline. PostgreSQL is the single source of truth.

  • A Flutter shell renders every application, on web and on mobile, from the same definitions.
  • A generic API endpoint behind one gateway means applications do not each invent their own backend.
  • Per-application schemas share one PostgreSQL server, one backup policy, one operations story.
  • Firebase provides authentication and file storage, so identity and uploads work the same everywhere.

What that buys you

The expensive part of business software is rarely the first screen. It is the twentieth screen, the fifth customer's permission model, and the third year of maintenance. A framework that treats every screen as data changes that economics.

  • A new industry application is a set of definitions, not a new project.
  • Fixes and improvements reach every application they apply to at once.
  • One visual language across products, so users learn once.
  • A clean environment can be rebuilt from the definitions at any time.

The platform layer

The shared services nobody has to build again

These are the shared services of the ecosystem — the parts every serious business product needs, modelled once so no application writes them twice.

CloudWinks

The framework itself: the registry, the shell, the navigation and the shared interface components.

Crux

The identity and company base that every other application extends for its own users and organisations.

KeyKook

Authentication and access: credentials, sessions, roles and multi-factor sign-in, applied consistently wherever a person can reach.

Murphy

Error logging, grouping and audit, with a client-side queue so an error survives a dropped connection. Outside applications report problems to Murphy through CosmosCall or BigTalk.

MediaMogul

Files, images and media, stored through the shared storage providers and served to any application.

TheReporter

Reporting and output, so applications produce documents and exports rather than reinventing them.

BigTalk & BullChat

BigTalk carries messaging across the platform. BullChat is the real-time chat platform and free public chat and social app, whose chats, feeds and groups work with every CloudWinks app.

WorkerBee & TheBoss

Background work and orchestration: jobs that run without a screen in front of them.

Roady

Maps and geospatial work: routes, pins, polygons and geofences, with location tracking for people who work away from a desk.

TheIntegrator

Connections to outside systems, with mappings verified as part of the build.

GoldenRule

Shared business rules, kept in one place so applications behave consistently.

CoderCody & Cloudify

Development and deployment tooling that lives inside the platform rather than beside it.

See the full list of platform and industry applications →

Industry applications

Applications across ten sectors

Each one is modelled to the way that industry actually works, and each inherits the platform underneath it, so identity, files, messaging, reporting and workflow come built in.

Definitions, not code

A table, a field, a screen and a menu are records in the database. Adding one does not mean writing or rebuilding a feature by hand.

One pipeline

Build, import and seed run in a fixed order from one orchestrator, so a clean environment can be produced again from the same definitions.

One identity base

Applications extend a shared record of users and companies, which is why the same account works across everything the framework carries.

Why CloudWinks

A complete foundation for business software

CloudWinks is a working system. The framework, the database model, the build pipeline and the client shell are built and running, and application definitions build and seed against them.

What that means in practice: a product built on CloudWinks starts from a foundation that already exists. The work is turning the right definitions into the product your team uses — a very different conversation from starting at an empty repository.

Every application shares the same identity, access, files, messaging and reporting, so your people learn one system and use one account across everything the framework carries.

Built and running

  • The framework shell, navigation and registration stack.
  • The database model: each application in its own schema, on one server.
  • The build, import and seed pipeline, rebuilt clean from scratch.
  • The generic query API and authenticated gateway.
  • Web and Android builds of the client from one codebase.

What every application gets

  • One account across every application, from the shared Crux identity base.
  • Authentication, roles and multi-factor sign-in from KeyKook.
  • Shared files, messaging, reporting and workflow services.
  • Business rules kept in one place by GoldenRule, so applications behave consistently.
  • Connections to outside systems through TheIntegrator.

Tell us what your business actually does.

We will tell you which parts of it CloudWinks already covers, which parts are a definition away, and which parts are genuinely new work.

Start that conversation