Coherence vs. Other Software

Building it Yourself (artisanal scripting and configuration)

Your team has probably built a lot of the components of Coherence already, yourselves. You've most likely got a plan for how to glue together dev environments, CI/CD environments, pipelines, deploy tooling, infrastructure management, environment automation for staging/previews and production, integration testing, and tie it all to your team's workflow in source control. You can build a dashboard on top of that, and document how it all works. Then you can figure out how to make it consistent across different teams and projects. You need to add features and complexity as your team scales - while keeping an eye on performance. Lastly, you need to keep it up to date as the software your team uses evolves/expands, as security updates are released, as software goes out of date, and as your infrastructure/cloud provider changes their API/SDK/CLI. When you adopt Coherence, we're just doing the work for you, taking it further than you would, and owning the maintenance of it. That doesn't sound so bad, does it?

  • Many teams we talk to estimate that they spend 20-30% of their time on the above. Additionally, it's often the best engineers on the team doing the work.
  • Infra work has a high disruption cost and is often a "silent killer" since we're all so used to the status quo.

PaaS (Heroku, render, railway, fly.io)

Coherence manages cloud resources in your own cloud account. This has advantages when it comes to several important areas: cost, compliance, extensibility, lock-in.

  • None of these platforms extend all the way to dev by offering Cloud IDEs in the same configuration (running VSCode as an app on the platform is not the same thing)
  • If you want to manage more than trivial build/test/deploy CI/CD pipelines you need to leave the platform and use a dedicated CI/CD provider that you need to configure yourself. This then causes you to lose baked in features like automatic staging environments (which you'll need to rebuild and maintain going forward). This is not just theoretical - for example render still does not have support for running DB migrations in their own build stage!
  • If you want to integrate cloud tools that are not supported add-ons (e.g. search/big data/data warehouse/high performance DBs like Dynamo or Spanner), you're on your own and cannot access the raw VPC under your resources. Same applies to using GPUs or other hosted products from the cloud providers.
  • Coherence manages multiple services in one application. Most PaaS products have copied Heroku where for example your frontend and backend are treated as 2 apps. This loses some of the magic of pipelines and other SDLC abstractions because coordinating between apps requires tooling outside the platform.

SDLC management platforms (github, gitlab)

Coherence uses external providers to manage source control, PR reviews, and other source code control functionality. We don't replace these tools. That said, looking more broadly GitHub and GitLab both offer similar feature set to Coherence: cloud IDE, environment management/DevOps dashboard, CI/CD pipelines, and integration with your tools such as JIRA or Slack. Coherence in the end is a more unified and opinionated version of the same toolkit.

  • For SCM, we integrate with GitHub for SCM, and it's on our roadmap to integrate with GitLab and Bitbucket.
  • Coherence requires 10x less configuration to get all of the moving pieces working. We have only one configuration across all functionality, as opposed to offering piecemeal bits that have to be seperately configured and which usually require external tools to be set up as well: for example to use GitLab environments you need terraform, kubernetes clusters, CI steps for running terraform, running deploys, pushing notifications, running integration tests, etc. all of which require additional work to set up and ongoing work to maintain.
  • With the existing tools, source control works out of the box but each additional functionality requires more configuration, often also modifications to existing tools and configurations. Our holistic approach saves you the work and maintenance while getting you the best version of your toolchain, and it's our job to keep making it better!

vs DevOps/Environment Automation (ReleaseHub, architect.io, quovery, Porter, Okteto, flightcontrol...)

Coherence manages the full lifecycle of infrastructure, requiring no pre-existing resources such as a kubernetes cluster or a self-managed infrastructure API. All you have to do is give our service account access to the necessary IAM roles in your AWS account or GCP project, and we will take it from there.

  • Many tools in this category achieve cross-cloud compatibility by limiting themselves to the lowest common denominator of tools (e.g. raw compute/networking/storage), which is something we're strongly against.
    • We believe that between first-party cloud services and marketplace solutions offered with deep integration into their systems (e.g. MongoDB Atlas, Elastic, Snowflake) the gap between what you can do in your own k8s cluster and what the providers offer will continue to grow.
    • Cloud services such as Cloud Run/App Runner/Fargate, RDS/Cloud SQL, Spanner/Aurora, DynamoDB/BigTable, Memorystore/Elasticache, managed SSL certs and load balancers, are all far too valuable to abandon.
    • One day, we even plan to offer versions of our system that run on for example CloudFlare Pages/Workers, which the k8s based systems in this category will never be able to do (nor would they add any value there, since they don't actually help manage the SDLC).
  • Seamlessly integrated Cloud IDEs alongside staging and production environments, providing reproducible & ephemeral dev environments for your team
  • Hosted Cloud SSH terminals for each environment automatically
  • Manage production in a distinct AWS Account or GCP Project without treating it as a separate application
  • CI/CD pipelines that run in your own cloud account, covering more than just Build/Deploy steps - for example running tests (unit & integration) or linting/formatting
  • Seamless no-code integration into 3rd party CI/CD platforms such as GitHub Actions
  • Full-stack integration tests on production-equivalent environments automatically without any new dependencies and with 3 lines of configuration, in both dev and staging/review/preview environments
  • Coherence links out to cloud tooling for monitoring/observability instead of reinventing the wheel. Cloudwatch and Stackdriver are building great tools and we want to help you configure and leverage them. DataDog integration is supported, too!
    • This "link-out" functionality makes it easy to use Coherence as a central infrastructure dashboard, and navigate a complex cloud setup with ease.

Cloud IDE (gitpod, GitHub Codespaces)

Coherence integrates a VSCode based cloud IDE into our platform. We also plan to offer JetBrains IDEs in the browser later this year. Similar to other Cloud IDE tools, you can supply configuration in your repo or Coherence user profile for things like VSCode config, .bash*, or vim/emacs configurations.

  • Coherence IDEs bake in the database migration and seeding knowledge used in other environments in order to automate creation of new dev environments that are robust and usable
  • Coherence IDEs have a unique per-user/per-branch lifecycle that encourages automation and frequent recreation - which keeps environments up to date and reduces drift across your team
  • Coherence IDEs are parallelizable so that you can have more than one open at once (e.g. you're working on a long-running feature and someone else asks you to take a look at a bug on their branch - you don't need to reset your sensitive state while in flight)
  • Since they live right alongside the rest of the tools, for managers or non-tech stakeholders who don't do dev environments often they increase discoverability and usability dramatically.
  • Consistency between projects means that you can maintain best-practices and standards automatically (without requiring additional configuration such as a .devcontainer or docker-compose file and the additional scripts/tooling required to use them)
  • Also means that everyone knows how to use and manage these environments. This also helps with onboarding new employees and project-switching internally
  • Of course we also plan to offer escape hatches by letting you mount the Cloud IDE environments locally over SSH, if you really hate the idea of a Cloud IDE - letting you still take advantage of the development services without limiting your editing experience. Coming soon!

Internal Developer Platform (Backstage, Humanitc)

Coherence includes a dashboard UI that lists environments, links to metrics/logs, manages configuration (env vars/files) and resources (e.g. database or cache). We will also offer a way to link to docs and policies/procedures, as some products here do. In this way it's similar to this category. But with these platforms there's a UI to configure on top of a host of self-managed tools (terraform, kubnernetes, bash, CI/CD, etc...).

  • With Coherence, one configuration manages both the developer platform UI, as well as all the tools underneath it! It's truly operating at a higher level of abstraction while providing even more value by extending all the way to managed development and cloud-hosted shell environments for each deployment in your application.


These platforms are only full-stack if you're all-in on functions as a service (and usually with limited framework support). They also don't help with managing service infrastructure like databases or cache. Coherence is a true full-stack product that runs as many service containers as your app requires for each environment, and also manages infrastructure.

  • Coherence runs in your own cloud
  • Coherence includes Cloud IDEs for managed dev environments

Infrastructure as Code (terraform, pulumi, CDK, CloudFormation)

Coherence automatically configures GitOps for best-practice infra configuration for you, using the same infrastructure-as-code tools you're already using. Using the same simple configuration as the rest of our platform, each git push or branch creation/deletion updates infrastructure configuration in our system, and we generate new infrastructure as code files and apply them on your behalf to your cloud account(s).

You can still manage your own terraform for additional resources in your account that we don't configure on your behalf (you can even import the resources we create into your state and add additional resources that know about them).

In short, Coherence does not replace Infrastructure as Code, it helps you manage it by generating it for you from our simple configuration format.

CI/CD (CloudBees, CircleCI, GitHub Actions, GCP Cloud Build, AWS CodeBuild)

Coherence does not operate its own CI/CD platform. Instead, we dynamically generate best-practice compliant pipelines for you, using the same simple configuration as the rest of our platform. These pipelines then run on CI/CD providers. Our vision is to give you a wide range of choices in which provider we generate pipelines on, enabling you to change providers without any work on your end. The default is to use the build service provided by the cloud where we're deploying your application, as generally it's the least expensive and it keeps your vendor count down which has security/compliance and reliability benefits.

Coherence can integrate GitHub Actions as a dependency in your Coherence builds out-of-the-box, enabling use cases such as parallelized/matrix testing.

Using Google Cloud Run or AWS App Runner

The biggest pain points we hear about this class of tools are:

  • inability to run worker processes for async jobs
  • need endpoints for cron tasks and also need to configure cloud scheduler (recent additons of "jobs" in beta addresses this for Cloud Run)
  • inability to get a shell/REPL for a service
  • CI/CD across multiple services (e.g. frontend/backend)
  • serverless connector configuration needed if you use redis
  • managing environments for each branch is not supported out of the box
  • CDN is not supported for frontend assets without additional configuration
  • No ability to put multiple App Runner apps behind one load balancer if you have more than one service

Coherence gives you integrated solutions to all of these problems, without any glue code or configuration on your end!

AWS CodeCatalyst

Coherence is also a pipeline-based workflow that unifies software development and delivery. Some key differences are:

  • Integration with other clouds such as GCP
  • Integration with github and github actions
  • Per-branch development environments
  • Hosted cloud shell per-environment
  • Coherence requires no additional configuration to use development environments. CodeCatalyst uses different configuration files for development.
  • Built-in support for running tests and performing seed & migration steps in pipelines
How Coherence Works