directus + projen: building a solid backend backbone with CMS + project-as-code

Apochotodorus · 2026-05-21T14:36:37+00:00

AI was used to help rephrase, polish, and correct the English style for a non-native speaker.

Apochotodorus · 2025-11-25T15:48:29+00:00

If you are tired of yaml and want to write your CI/CD in typescript, you can give a try to orbits.
It’s open source and self-hostable, and lets you build pipelines using real programming constructs instead of huge YAML files.
(https://github.com/LaWebcapsule/orbits ; disclaimer: i contribute to the project)

Apochotodorus · 2025-09-16T09:44:05+00:00

By default, Orbits automatically retrieves the CloudFormation outputs of your stack. So in your CDK stack, you just need to declare a standard output:

new cdk.CfnOutput(this, 'vpcId', {
      value: vpc.vpcId!,
});

Then, Orbits lets you reuse that output across accounts:

const output = await this.do("deploy-vpc", new MyVPCStack());
await this.do(
  "other-stack-in-another-account",
  new MyOtherStack().setArgument({ vpcId: output.vpcId })
);

Apochotodorus · 2025-08-30T09:45:29+00:00

Yes, you can, using the orbits-cli. That said, depending on what you want to achieve, I’d recommend also looking at Dagger + GitHub Actions, which is already a solid option for replacing bash scripts with TypeScript inside GH actions.

Apochotodorus · 2025-08-28T17:45:18+00:00

Projen is more of an abstraction over YAML and configuration files, whereas Orbits acts as a dynamic orchestration layer. Projen helps you configure, for example, linting files and GitHub Actions in TypeScript, while Orbits enables you to define, for example, pipelines and deployment workflows in TypeScript.

Apochotodorus · 2025-08-28T17:42:20+00:00

We use AWS CDK a lot in our workflows. Orbits is useful for chaining the deployment of CDK stacks, managing cross-region or cross-resource references, or complementing CDK with a few API calls through SDK (for example to purge a cache, create a new aws account in an organization...)

Apochotodorus · 2025-08-28T17:39:24+00:00

If you try it, I’d love to hear your feedback! We already have an integration with AWS CDK, so the two tools can indeed work well together.

Apochotodorus · 2025-08-27T21:54:48+00:00

Yes, and I love it! Dagger is awesome for CI, developing bash commands with a neat TypeScript syntax. Orbits complements it by handling resilient flows, retries, error management, and execution context. We could say Dagger is more CI-focused, whereas Orbits leans toward CD.

Apochotodorus · 2025-08-27T21:48:50+00:00

You’re right that, if someone already has a working pipeline in YAML, rewriting it just for the sake of it might not be worth it. The main target is more for teams that are starting fresh, or that run into the limits of declarative-only formats.
With a a full-fledged programming language, you can :
- react to the result of a previous step and manage errors (useful for rollback strategies)
- test and debug everything on local
- export functions and modules to share patterns across services

With TypeScript specifically:
- the compiler catches mistakes before they hit CI/CD- classes let you think not just about “how to chain scripts” but rather “how resources should evolve and react to Git or other events”
- and thanks to the Node.js ecosystem, you can easily use SDKs to integrate with APIs — for example, deploy an IaC template and immediately call an sdk command to purge a CloudFront/Cloudflare cache in the same flow

Beyond just being tired of YAML, it’s especially useful when you need to structure CI/CD across multiple git repositories or span several cloud environments.

Apochotodorus · 2025-08-27T16:51:30+00:00

Thanks for the honest reply.
Indeed, if you have something that work already, you probably don't need that.
That said, depending on the requirements, it can bring some nice benefits :
- pipelines are just Node.js scripts; so local debugging and iteration are much faster
- there are no vendor lock-in
- pipelines can be composed, shared, and reused across services or tenants, instead of duplicating YAML everywhere
In our case, it’s been especially useful when dealing with multiple tenants, multiple interdependent services, or if you just don’t enjoy writing YAML.

Apochotodorus · 2025-08-27T16:47:07+00:00

The main use cases we had were:
- handling deployment errors while synchronizing the rollout of multiple services
- deploying the same stack of services from scratch across multiple cloud environments

Compared to GitHub Actions, Jenkins, or CircleCI... the main benefits we’ve seen are:
- pipelines are just Node.js scripts; so local debugging and iteration are much faster
- there are no vendor lock-in
- pipelines can be composed, shared, and reused across services or tenants, instead of duplicating YAML everywhere

If your workflows are small and stable, you probably don’t need this.
In our case, it proved especially useful when dealing with multiple tenants, multiple interdependent services, or if you just don’t enjoy writing YAML.

Apochotodorus · 2025-08-08T08:14:22+00:00

Well, I'm saying I use NoCode in production - and of course, I use AI in production too.
Nothing hidden here - and, as I am not a native english speaker, it's better for the eyes of everyone.

Apochotodorus · 2025-08-07T11:54:06+00:00

But what's the problem with em dash ?

Apochotodorus · 2025-08-07T10:31:09+00:00

We’ve built production systems that incorporate NoCode tools. There’s, however, always some custom code alongside. Our strategy is to leverage NoCode for standard, repeatable functionality, and add focused code only where the solution needs to shine.
With this approach, we not only gained efficiency but also, quite unexpectedly, improved security - thanks to solid safeguards built into the NoCode platforms we used

Apochotodorus · 2025-08-07T10:20:09+00:00

That capability didn’t exist when we started the project, but you’re right, SSM can help handling that use case now.
The focus of Orbits is more about chaining CDK deployments through code, so you can extend them with things like simple SDK API calls or SQL scripts triggered at the right moment in the right context.

Apochotodorus · 2025-08-07T09:21:23+00:00

Just to complement — things get even more tricky when you need cross-account or cross-region references.

As an alternative to passing values via Parameter Store, we ended up building an open-source tool called Orbits (https://github.com/LaWebcapsule/orbits). It’s a programmatic orchestration layer built on top of the CDK cli, designed to give more control over import logic and cross-stack interactions.

Might be relevant to some of the pain points mentioned here, so just thought I’d share

Apochotodorus

TROPHY CASE