Skip to content
The platform

Every artifact, traceable to the code it came from.

saasups reads a repository, maps its components and the AWS services they need, prices three target tiers and prepares a reviewed deployment bundle. The saasups team applies it in your AWS account, with your approval. The examples on this page are illustrative and shaped like real output.

Component inventory

What is actually running in the codebase?

Give saasups a public GitHub repository URL. It reads the repository over the GitHub API without cloning it, identifies the components, their languages and dependencies, and assigns each component a 7-R strategy with its rationale. A component the evidence cannot place gets no strategy rather than a default.

  • Every finding cites the file and line it came from
  • Secret values never reach a report: a SHA-256 fingerprint stands in for the literal
  • Hard blockers are separated from customer-owned security advisories; only hard blockers gate a deployment

Private repositories, source archives and multi-repository projects are agreed in a technical demo.

  1. L1

    Scan-only

    A deterministic scorecard from configuration and manifests. No language model is called.

  2. L2

    Structural

    The scan-only evidence plus repository context, read by a language model that reasons over the evidence package rather than raw files.

  3. L3

    Deep

    The structural read over a wider slice of the repository, with subdirectory discovery and a per-component pass on multi-module repositories.

Node.js API with PostgreSQL and RedisIllustrative example
ComponentKind7-RWorkload
apiHTTP serviceReplatformtransaction heavy
workerbackground jobsRehostbursty
webstatic front endReplatformlight
postgresdatabaseReplatformio intensive
rediscache—light
  • config/database.yml:14Hardcoded database passwordadvisorysha256:3f9a1c0b7e2d·len=24·token
  • src/ledger.ts:41Connects to a fixed private address (unreachable on-prem dependency)hard blocker
AWS service map

Which AWS services does the plan need, and why each one?

Each service in the plan is marked confirmed when a file-cited signal or finding backs it, or inferred when it follows from the component's workload and the architect's rationale. The map is derived from evidence the assessment already captured; no model is asked to invent it.

  • Compose services, configuration keys and findings are the signals
  • Landing-zone services such as Secrets Manager, SSM parameters and CloudWatch come with every bundle

A confirmed service is a cited need, not a provisioning promise; see what the bundle generates below.

AWS service mapIllustrative example
  • Amazon EC2 + Auto ScalingprimaryinferredFrom the component's workload profile and the architect's rationale
  • Amazon RDS for PostgreSQLconfirmeddocker-compose.yml:18 — service db runs image postgres:16
  • Amazon ElastiCacheconfirmedconfig/cache.ts:7 — REDIS_URL read from the environment
  • AWS Secrets Managerconfirmedconfig/database.yml:14 — hardcoded credential, value fingerprinted
  • Amazon S3confirmedsrc/uploads.ts:31 — uploads written to local disk
  • Amazon CloudWatchinferredLanding-zone foundation, provisioned with every bundle
Priced target tiers

What will it cost to run, at which level of resilience?

The same component inventory is sized three ways: cost-optimized consolidates light components onto shared compute in a single availability zone; production right-sizes each workload with multi-AZ data; high availability adds replicas, read replicas and headroom everywhere. Supporting services are billed once per tier, not once per component.

  • Monthly, annual and three-year figures, broken down by cost category
  • Reserved-instance and savings-plan multipliers applied as explicit assumptions
  • A deep link reproduces the plan in the AWS Pricing Calculator

An estimate is not an AWS bill. It depends on region, sizing, traffic and reserved-plan assumptions, all of which are printed next to it.

Priced target tiersIllustrative example
us-east-1 · on-demand · medium traffic profile

Cost-optimized

Shared compute, single AZ, smallest sizes

$412/mo

  • Compute$96One EC2 Auto Scaling group shared by api, worker and web
  • Database$118RDS for PostgreSQL, single AZ
  • Networking$146Application Load Balancer, one NAT gateway
  • Secrets & observability$52Secrets Manager, SSM parameters, CloudWatch

Production

Right-sized per workload, multi-AZ data

$1,180/mo

  • Compute$318EC2 Auto Scaling per workload, two replicas
  • Database$402RDS for PostgreSQL, Multi-AZ
  • Networking$322Application Load Balancer, NAT gateway per AZ
  • Secrets & observability$138Secrets Manager, SSM parameters, CloudWatch

High availability

Replicas and multi-AZ everywhere, headroom sizing

$2,460/mo

  • Compute$742EC2 Auto Scaling per workload, multi-AZ, headroom
  • Database$918RDS for PostgreSQL, Multi-AZ with a read replica
  • Networking$548Application Load Balancer, NAT gateway per AZ, CloudFront, WAF
  • Secrets & observability$252Secrets Manager, SSM parameters, CloudWatch

Monthly, Annual, Three-year figures, with a deep link into the AWS Pricing Calculator. Illustrative figures. An estimate is not an AWS bill.

Generated by the bundle

  • VPC and subnets
  • Application Load Balancer
  • EC2 Auto Scaling or EKS
  • RDS or Aurora
  • ElastiCache
  • S3
  • ECR
  • Secrets Manager and SSM parameters
  • CloudWatch log groups and alarms
  • ACM certificates and Route 53 records when a domain is set

Priced, not generated

  • AWS Lambda
  • Amazon MSK
  • Amazon Kinesis
  • VPC endpoints
  • Amazon CloudFront
  • AWS WAF

Compute paths: Amazon EC2 with Auto Scaling and Amazon EKS. Data stores are encrypted at rest with AWS-managed keys.

Deployment bundle

What gets generated, and has anyone checked it?

From the chosen tier saasups generates an OpenTofu/Terraform bundle, a continuous-delivery workflow for your CI, and a starter Dockerfile per language where the repository has none. Generated files carry a do-not-edit header; the files meant for you to edit say so.

  • GitHub Actions with SHA-pinned actions, GitLab CI, Jenkins or AWS CodePipeline
  • Validated before it is offered: fmt, init, validate, tflint, checkov
  • Only init and validate can fail the bundle; the rest are advisory and reported as warnings

A generated Dockerfile is a reviewable starter, never a build the launch chain will ship unreviewed.

deploy bundleIllustrative example
  • deploy/terraform/terraform.tfvars.jsongeneratedthe sizing the report shows, to the cent
  • deploy/terraform/main.tfgeneratedstatic structure reading var.*; VPC from terraform-aws-modules/vpc
  • deploy/terraform/providers.tfeditablebackend and provider settings; never overwritten on re-generate
  • Dockerfilestarteronly when the repository has none
  • .github/workflows/deploy.ymlgeneratedor .gitlab-ci.yml, Jenkinsfile, buildspec.yml
  • deploy/scripts/preflight.shgeneratedbuild, push and release scripts alongside it
  • deploy/README.mdgeneratedwhat the bundle contains and how it is applied

CI workflow forGitHub ActionsGitLab CIJenkinsAWS CodePipeline

  1. fmt -checkadvisory
  2. init -backend=falsegating
  3. validategating
  4. tflintadvisory
  5. checkovadvisory
Migration order

In what order should the components move?

Dependencies are sorted topologically and bucketed into waves; stateful components go into the foundation wave so stateless services can rely on them. Each wave gets a cutover runbook in Markdown, and the operator console produces an executive summary alongside it.

  • Scope, pre-cutover, cutover, validation, rollback and post-cutover, per wave

Wave plans and runbooks are produced on the operator side and shared as Markdown. The customer workspace has no dependency graph view and no document export.

Migration wavesIllustrative example
  1. Wave 1

    Foundation

    postgresredis
  2. Wave 2

    Stateless services

    apiweb
  3. Wave 3

    High-coupling workloads

    worker

Runbook per wave: Scope · Pre-cutover · Cutover · Validation · Rollback · Post-cutover. Executive summary alongside, as Markdown.

Operator-assisted deployment

Who applies it, where, and what stops a bad apply?

The saasups team applies the approved plan in your AWS account, with your approval. Nothing is applied from a button in a customer workspace: a plan is previewed, every hard blocker must be explicitly accepted with a reason, a named operator approves that exact plan by fingerprint, and only then does the runner apply it.

  • Your account is reached through an IAM role your CloudFormation stack creates, with an ExternalId; sessions are short-lived and no long-lived customer credentials are stored
  • Terraform state lives under a per-deployment key in a dedicated bucket
  • A guard refuses to apply into a payer or management account
  • Approve, apply and destroy each write an audit row
  • The same runner image, with preflight, plan, apply, destroy, status and explain, runs from your own CI if you prefer

Supported compute paths are EC2 with Auto Scaling and EKS. Services the plan prices but the bundle does not generate are listed by name in the bundle's warnings.

Review access and deployment controls
Operator-assisted deployment
  1. Connectyou

    You launch a CloudFormation stack in your account. It creates the IAM role saasups assumes, gated by an ExternalId.

  2. Plansaasups operator

    A plan preview runs against your account. Its summary and cost are what the approval refers to.

  3. Accept hard blockerssaasups operator

    On your decision. Every unaccepted hard blocker stops the deploy; acceptance records a reason code.

  4. Approvesaasups operator

    A named operator approves this exact plan by fingerprint. A plan that drifted cannot ride an earlier approval.

  5. Applyrunner

    The runner applies through the cross-account role, in your account.

  6. Statusrunner

    Read-only view of the live estate.

  7. Destroysaasups operator

    Requires the deployment identifier typed back and checked server-side.

Also in the platform

One more thing the platform does today.

Access and audit

Email and password with mandatory two-factor authentication: a TOTP app plus encrypted backup codes, reset with a saasups operator. Sign-in is rate-limited, and approvals, applies and destroys are written to an audit log.

Access & control
RoadmapRoadmap

Where the same application context goes next.

The vision extends this context into continuous AI SRE and FinOps, controlled intervention and remediation pull requests. These are roadmap capabilities and are not part of today's workflow.

Start with your application

Let’s map your next step on AWS.

Discuss your codebase, target architecture and delivery requirements in a technical demo.

Have an open-source application? Request a public repo assessment.

Requests are reviewed before analysis. Public reports are published with your consent.