Skip to content
Nubent

/AWS foundation architecture

AWS architecture built with Terraform from the start

We design and build the foundation of your AWS platform: separate accounts per environment, networking, access, pipelines and observability, all as code in Terraform. It is the infrastructure you wish you had from the beginning, designed so your product can grow without a rebuild every time the scale changes or a demanding customer signs.

/Diagnosis

Signs it is time

New product, infrastructure still open

You are launching or rebuilding a product and want the right architecture decisions in place before traffic and customers make them hard to change.

Everything in one account

Development, staging and production share the same AWS account, with broad permissions and resources created by hand in the console.

Infrastructure only one person understands

The setup lives in the head of whoever built it, and every change depends on that person being available.

A customer wants guarantees

An enterprise customer or a due diligence process asks about environment separation, backups, access and failure recovery.

/What we deliver

Concrete deliverables, in your repository

  • Architecture design

    Diagrams and documented decisions on compute, data, networking and security, aligned with the AWS Well-Architected pillars.

  • Account structure

    Accounts per environment with AWS Organizations, guardrails through service control policies and centralized access with IAM Identity Center.

  • Terraform modules

    The full infrastructure as code, with remote state, reusable modules and a reviewable plan on every pull request.

  • CI/CD pipelines

    Automated deployment of application and infrastructure, with approvals for production and simple rollback.

  • Baseline observability

    Logs, metrics, traces and alarms in Amazon CloudWatch from the first deployment, with dashboards per service.

  • Backups and recovery

    AWS Backup policies, encryption with AWS KMS and a tested restore procedure.

/How we work

Our process

  1. Assessment

    We get to know the product, the team, customer requirements and what already exists, with read-only access if there is an account in use.

  2. Design

    We propose the architecture and its trade-offs, and agree on priorities before writing a single line of Terraform.

  3. Build

    We implement through pull requests in your repository, environment by environment, with your team reviewing every step.

  4. Ongoing operations

    We support the first real deployments, adjust what is needed and, if you want, keep operating the platform.

How we design an AWS architecture that scales with your product

A good AWS architecture is not the most sophisticated one: it is the one your team can run and the one that survives the next order of magnitude without a rebuild. We start from what the product actually needs, such as traffic patterns, data types, customer requirements and team size. From there we choose compute, database and networking, and document what we ruled out and why.

We use the AWS Well-Architected pillars as a checklist and adapt them to each case: operational excellence, security, reliability, performance efficiency, cost optimization and sustainability. For an early-stage startup we prioritize simplicity and speed; for a scale-up with enterprise customers, isolation, auditing and failure recovery. What looks like overengineering in year one becomes mandatory the day the first enterprise customer signs.

Infrastructure as code with Terraform

Everything we build lives in Terraform, in your repository. Networks, accounts, databases, queues, permissions and alarms are defined as code, with locked remote state and reusable modules. Every change goes through a pull request that shows the plan before it is applied, so your team reviews infrastructure the same way it reviews application code.

Beyond traceability, infrastructure as code means spinning up an environment for a demo, a dedicated customer or a new region is no longer a project. The drift between staging and production disappears, because both come from the same code with different parameters, and manual configuration mistakes stop being a recurring cause of incidents.

Accounts, networking and access done right from the start

Separating environments into different AWS accounts is the cheapest decision to make early and the most expensive one to fix later. We set up AWS Organizations with accounts for production, staging, development, security and logs, guardrails through service control policies and human access through IAM Identity Center, with no IAM users holding long-lived keys.

The network is designed for growth: non-overlapping address ranges, private subnets for data and compute, controlled internet egress and VPC endpoints for AWS services. So when the time comes to connect an office, a partner or a second region, nothing has to be renumbered and the network does not have to be rebuilt.

CI/CD and observability included from the first stage

A platform without automated deployments or visibility is unfinished. We deliver pipelines that build, test and deploy both the application and the infrastructure, with explicit approvals for production. CloudWatch alarms, centralized logs and traces are set up alongside each service, so your first incident does not leave you hunting for clues on servers with no logs.

At the end of the project, your team gets the code, diagrams, runbooks and handover sessions. If you would rather focus on the product, we can keep running the platform with the same model: changes through pull requests, regular reviews and an engineer who knows your environment because they built it.

/FAQ

Building on AWS: frequently asked questions

Another question? Write to hello@nubent.com and an engineer will answer.

What does an AWS consultancy do when building an architecture from scratch?

It turns product needs into infrastructure decisions and then implements them. For us that means designing accounts, networking, compute, data and security, writing everything in Terraform, building the CI/CD pipelines and setting up observability. The deliverable is not a document: it is a working platform in your account, with the code in your repository.

Terraform or AWS CloudFormation?

Both are valid. We default to Terraform because there are maintained modules for almost everything, the change plan is easy to review in pull requests and it can also manage providers outside AWS, such as DNS, monitoring or repositories. If your organization has already standardized on CloudFormation or AWS CDK, we work with that tool so you do not end up with two ways of operating.

Does a startup need multiple AWS accounts?

Yes, even if it is just a few. Separating at least production from everything else limits the blast radius of a mistake, simplifies permissions and makes the cost of each environment visible. Setting it up early with AWS Organizations is a small effort; moving later, with data and customers in production, takes migrations and maintenance windows nobody wants to plan.

How long does it take to build the foundation of an AWS platform?

It depends on scope. We work in incremental deliveries: first the account structure and networking, then compute and data, and finally full automation. Each stage is usable on its own, without waiting for the end of the project, and the design phase gives you a calendar based on what your platform actually needs.

What happens to the infrastructure when the project ends?

It is yours. The Terraform code, pipelines, documentation and access live in your accounts and repositories from the start; there are no proprietary components or hidden dependencies. You can run it with your own team, bring someone else in or keep working with us on an ongoing operations basis.

Next step

Let's talk about your Building on AWS project

30 minutes with an engineer. Concrete next steps, whether or not you work with us.