backend-standards

Enforce CMDO separation of infrastructure and domain logic in Node.js/TypeScript backends.

39|3|Updated Nov 21, 2025
One-click install
npx skills add https://github.com/LiorCohen/sdd --skill backend-standards-liorcohen
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: backend-standards
Source: https://github.com/LiorCohen/sdd/tree/main/plugin/fullstack-typescript/skills/components/backend/backend-standards
Command: npx skills add https://github.com/LiorCohen/sdd --skill backend-standards-liorcohen

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

CMDO architecture clarity by enforcing strict separation between infrastructure and domain concerns in Node.js/TypeScript backends.

Core Features & Use Cases

  • Layered architecture guidance: Operator, Config, Controller, Model, and DAL with clear responsibilities.
  • Entry point discipline: only src/index.ts bootstraps the app; all other files are pure exports.
  • Telemetry and observability: logging and metrics initialization in Operator; structured logs with OpenTelemetry.
  • Consistent file naming and module boundaries: lowercase_with_underscores filenames; no DAL repositories; one use-case per file.
  • Clear wiring: Controllers assemble dependencies for Model use-cases and expose HTTP handlers; health checks on a separate port.

Quick Start

Refactor your backend to follow the CMDO standards across all layers.

Frequently Asked Questions about backend-standards

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I enforce strict separation between infrastructure and domain logic in a Node.js backend?

To enforce infrastructure and domain separation in a Node.js backend, apply the CMDO architecture pattern. It strictly defines boundaries for Operator, Config, Controller, Model, and DAL layers, ensuring domain logic remains isolated from infrastructure concerns.

What is the CMDO architecture pattern in TypeScript?

The CMDO architecture pattern in TypeScript is a layered design standard separating backends into Config, Model, DAL, and Operator components. It enforces strict file structures, naming conventions, and one use-case per file to maintain clean backend architecture.

How do I structure Node.js entry points and telemetry for clean architecture?

Structure Node.js entry points and telemetry by limiting bootstrapping to src/index.ts while making all other files pure exports. Initialize logging and OpenTelemetry metrics strictly within the Operator layer for centralized observability.

Does the CMDO standard require specific file naming and dependency wiring for controllers?

Yes, the CMDO standard requires lowercase_with_underscores file naming and prohibits DAL repositories. Controllers must assemble dependencies for Model use-cases and expose HTTP handlers, while vetted health checks run on a separate port.

What is the best way to refactor an existing Node.js backend to use layered design?

The best way to refactor a Node.js backend to layered design is migrating files to CMDO boundaries. Reorganize logic into Operator, Config, Controller, Model, and DAL layers, enforcing one use-case per file and strict dependency controls.

When should I not use strict layered architecture for my TypeScript backend?

You should not use strict layered architecture like CMDO for small prototypes or scripts where overhead outweighs maintainability benefits. The pattern enforces one use-case per file and explicit module boundaries, which requires significant upfront structural commitment.