DevOps, Automated.

The cloud platform that automates provisioning, deployments, and networking all at once

Get started for free
DevOps, Automated.
Let us automate that
DevOps is the intersection of several tools and processes. All of which can be automated with Architect.
Application delivery

Application delivery

Developers waste hours of time writing tedious pipelining scripts and babysitting deployments. Help your developers focus on your product, and let us automate that.

Securing your networks

Network security

Network security is critical to protecting your customers and business, but instrumentation is tedious and error prone. Let us automate that.

Provisioning environments

Environment provisioning

Developers need to run and test their applications in private sandboxes and preview environments, but DevOps engineers never have time to support temporary environments. Let us automate that.


DevOps starts with Developers
Our cloud platform and Architecture-as-Code framework are everything developers need to build and ship new apps and services to production-grade environments.
Declarative config files

Define your apps, services, and architecture using a declarative configuration file so that your stack can be run anywhere, by anyone, for any reason

Different environments use different hostnames and tools for service discovery, load balancing, and security. Don't let that slow down development and let Architect configure it for you.

Your app is distributed, and so is the knowledge of its architecture. Leverage familiar dependency management practices to connect to databases, message queues, peer APIs, and other external dependencies.

Running and testing features and services is critical for developer productivity. Architect's automation isn't just for production environments, but for private developer environments as well.

The earlier a feature can be tested in a production-like environment, the faster the changes can be trusted and released. Architect's automation enables full environments to be provisioned and destroyed with each pull request.

Consistency is the key to successful deployments. Deploying with Architect is the same for every service and every environment, making production deployments safe and reliable for every developer on your team.

# Describe services, cronjobs, and more in a declarative
# format as simple as docker-compose
services:
  auth:
    build:
      context: ./auth-service
    interfaces:
      rest:
        port: 8080
    environment:
      LOG_LEVEL: info

  api:
    build:
      context: ./api-service
    interfaces:
      rest:
        port: 8081
services:
  auth:
    build:
      context: ./auth-service
    interfaces:
      rest:
        port: 8080
    environment:
      LOG_LEVEL: info

  api:
    build:
      context: ./api-service
    interfaces:
      rest:
        port: 8081
    environment:
      # Populate peer addresses by reference. Architect will
      # automatically instrument service discovery and strict
      # network policies with each deployment
      AUTH_URL: ${{ services.auth.interfaces.rest.url }}
# Claim dependencies that will be automatically provisioned
# as-needed to power your own services
dependencies:
  postgres/postgres: 13
  company/auth: 1.2.0

services:
  api:
    build:
      context: ./api-service
    interfaces:
      rest:
        port: 8081
    environment:
      # Automatically connect to APIs exposed by dependencies w/out
      # getting lost in the details
      DB_URL: ${{ dependencies['company/auth'].interfaces.db.url }}
      AUTH_URL: ${{ dependencies['company/auth'].interfaces.app.url }}
# Single command to stand up private dev environment
$ architect deploy --local ./architect.yml

# ...streaming docker compose logs...
Wrote docker-compose file to: ~/.config/architect/docker-compose/architect.yml
[+] Building 0.9s (11/12)                                                                                                              
 => [architect_cloud-api-worker-a8ucsqbe internal] load build definition from Dockerfile                                          0.0s
[+] Building 3.9s (12/21)                                                                                                              
 => [architect_cloud-api-worker-a8ucsqbe internal] load build definition from Dockerfile                                          0.0s
 => => transferring dockerfile: 671B                                                                                              0.0s
 => [architect_cloud-app-1ywfwdkp internal] load build definition from Dockerfile                                                 0.0s
 => => transferring dockerfile: 1.04kB                                                                                            0.0s
 => [architect_auth-app-frykeeda internal] load build definition from Dockerfile                                                  0.0s
 => => transferring dockerfile: 210B                                                                                              0.0s
 => [architect_cloud-registry-proxy-phkgeuwd internal] load build definition from Dockerfile                                      0.0s
 => => transferring dockerfile: 481B                                                                                              0.0s
# ...
# GitHub actions workflow template
name: Architect Create Preview

# Triggers on every pull request
on:
  pull_request:
    branches:
      - master

jobs:
  create_preview:
    runs-on: ubuntu-latest
    steps:
      # ...
      - run: sudo npm install -g @architect-io/cli
      - run: architect login -e me@domain.com -p mysecurepassword
      - run: architect register ./architect.yml -t preview-${{ github.event.number }}
      - run: architect environment:create preview-${{ github.event.number }} -a architect-account --platform preview-platform || exit 0
      - run: architect deploy --auto_approve -a architect-account -e preview-${{ github.event.number }} architect-account/my-component:preview-${{ github.event.number }}
hero

Distributed apps, centralized governance
Our cloud platform gives you visibility, protection, and compliance without sacrificing productivity
Service catalog
Application &
service catalog

View your full portfolio of apps and services, and share it with your team to ensure that no one is re-inventing the wheel.

Cluster management
Cluster management
& access control

Architect helps teams create, manage, and distribute access to the clusters that will play host to production and developer environments alike.

Centralized governance
Centralized
governance

Visualize and assign policies for all of your production and non-production environments with Architect Cloud. Deployments will automatically inject policies and settings without impacting developer productivity.

Zero trust
Zero trust
cloud security

Architect's deploy process includes the unique ability to enrich deployments with strict network policies, ensuring that environments are as secure as possible at all times.

Audit trail
Compliance &
audit trails

Every deployment comes complete with a detailed breakdown of the changes applied, how long the deployment took, and who triggered the deployment – all the information needed to maintain compliance and protect your business.


Tried, Tested, Trusted.
Architect is used by the best in the business from development to production
Decision Point
SimpleCommands
Zylotech
Decision Point

Our team struggled with synchronizing our environments and wasted the time of our most senior engineers. Architect simplified deployments so much that it not only improved synchronization but also reduced our engineering overhead. What used to take 3 senior engineers to do is now no more than a part-time job.

  • Stanis Laus Billy
    Stanis Laus Billy

    Vice President of Engineering

  • Get Started

    Ready to try Architect?

    Get started for free
    See examples on GitHub
    Contact us for pricing
    Architect logo
    © Architect.io 2021