How GitHub Actions and AWS CodePipeline differ on where pipelines are defined, triggers, AWS credentials, build environments and ECS deploys, with a workflow and a pipeline for the same service, and how to drop the infrastructure step from either.

Deploying a backend to AWS from GitHub comes down to two common options. GitHub Actions keeps the pipeline in the repository as YAML and assumes an AWS role per job. AWS CodePipeline keeps it inside AWS as stages and actions, with CodeBuild doing the build.
This comparison covers definitions, triggers, credentials, builds and ECS deploys for the same service. It also shows how Encore removes the infrastructure part of the pipeline.
Each option is covered below, starting with Encore.
Encore brings infrastructure from code, with a platform that builds and deploys into your own AWS account. Once you link the GitHub repository, Encore builds and runs tests on each pull request, creates a preview environment for it, and deploys when you push to the branch configured for an environment.

There is no deploy step to script, because the resources come from the code. A service that declares a database gets RDS on deploy:
// orders/orders.go
package orders
import (
"context"
"encore.dev/storage/sqldb"
)
var db = sqldb.NewDatabase("orders", sqldb.DatabaseConfig{
Migrations: "./migrations",
})
type Order struct {
ID int64 `json:"id"`
Status string `json:"status"`
}
//encore:api public method=GET path=/orders/:id
func Get(ctx context.Context, id int64) (*Order, error) {
o := &Order{ID: id}
err := db.QueryRow(ctx, `SELECT status FROM orders WHERE id = $1`, id).Scan(&o.Status)
return o, err
}
The schema lives in a migration next to the service:
-- orders/migrations/1_init.up.sql
CREATE TABLE orders (
id BIGSERIAL PRIMARY KEY,
status TEXT NOT NULL DEFAULT 'pending'
);
In an AWS environment Encore creates the matching resources: Fargate or EKS for compute, RDS for the database, SNS and SQS for Pub/Sub, S3 for buckets, and Secrets Manager for secrets. Encore provisions an IAM role for the service. Migrations run as part of the deploy. When a pull request adds a topic or a bucket, the preview environment, which is hosted by Encore, gets it too, so reviewers test the change with its infrastructure.
An AI coding agent can then add a queue and its handler in one diff, run both with encore run, and open a pull request that is the whole change, with no workflow file or IAM policy to edit alongside it.
Run in your terminal to get started locally.
Best fit: teams on GitHub deploying backends to AWS who want every pull request previewed with its infrastructure and every merge deployed from a push.
GitHub Actions runs workflows defined in YAML under .github/workflows, triggered by pushes, pull requests, tags or manual dispatch. For AWS, the important part is credentials: with GitHub as an OIDC provider, each job assumes an IAM role whose trust policy matches the repository and branch or environment. A deploy to ECS looks like this:
# .github/workflows/deploy.yml
name: deploy
on:
push:
branches: [main]
permissions:
id-token: write
contents: read
jobs:
deploy:
runs-on: ubuntu-latest
environment: production
steps:
- uses: actions/checkout@v4
- uses: aws-actions/configure-aws-credentials@v4
with:
role-to-assume: arn:aws:iam::123456789012:role/github-deploy
aws-region: eu-central-1
- uses: aws-actions/amazon-ecr-login@v2
id: ecr
- run: |
docker build -t ${{ steps.ecr.outputs.registry }}/orders:${{ github.sha }} .
docker push ${{ steps.ecr.outputs.registry }}/orders:${{ github.sha }}
- uses: aws-actions/amazon-ecs-render-task-definition@v1
id: task
with:
task-definition: ecs/task-definition.json
container-name: orders
image: ${{ steps.ecr.outputs.registry }}/orders:${{ github.sha }}
- uses: aws-actions/amazon-ecs-deploy-task-definition@v2
with:
task-definition: ${{ steps.task.outputs.task-definition }}
cluster: prod
service: orders
wait-for-service-stability: true
Checks show up on the pull request, the marketplace has actions for most tools, and environments add required reviewers and scoped secrets before a production job runs. The cost is that the runner sits outside your VPC, so reaching a private database for migrations means a self-hosted runner, a bastion or a one-off ECS task.
CodePipeline models a release as stages (source, build, deploy) with actions in each. A GitHub source uses a CodeConnections action, and V2 pipelines add trigger filters on branches, file paths, Git tags and pull requests. The build stage is usually CodeBuild, configured by a buildspec:
# buildspec.yml
version: 0.2
phases:
pre_build:
commands:
- aws ecr get-login-password | docker login --username AWS --password-stdin $REGISTRY
build:
commands:
- docker build -t $REGISTRY/orders:$CODEBUILD_RESOLVED_SOURCE_VERSION .
- docker push $REGISTRY/orders:$CODEBUILD_RESOLVED_SOURCE_VERSION
- printf '[{"name":"orders","imageUri":"%s"}]' $REGISTRY/orders:$CODEBUILD_RESOLVED_SOURCE_VERSION > imagedefinitions.json
artifacts:
files:
- imagedefinitions.json
The deploy stage then uses the ECS deploy action, which reads imagedefinitions.json and rolls the service, or CodeDeploy for blue/green. Credentials never leave AWS: the pipeline and CodeBuild run with service roles, and CodeBuild can run inside your VPC to reach private databases. Manual approval actions and cross-account deploys are built in.
The pipeline itself lives in AWS, usually defined in CloudFormation or CDK in yet another repository, pull request feedback needs extra wiring, and iterating on it means deploying the pipeline before you can test it.
Pick Encore when the goal is shipping a backend to AWS with pull request previews and push-to-deploy, and you want the infrastructure to come from the same pull request as the code.
Pick GitHub Actions when the code is on GitHub, you want one tool for checks and deploys, and OIDC roles meet your security bar. Pick CodePipeline when releases must stay inside AWS, with VPC-local builds, approval stages and IAM-governed deploys across accounts.
When the code lives on GitHub, GitHub Actions is simpler: the pipeline is a YAML file in the repository, pull request checks and deploys share one tool, and OIDC gives jobs short-lived AWS credentials. CodePipeline fits better when the release process has to live inside AWS, with IAM-controlled stages, manual approvals and deploy actions run by AWS services.
Yes. Configure GitHub as an OIDC identity provider in IAM, create a role whose trust policy matches your repository and branch or environment, and use aws-actions/configure-aws-credentials with role-to-assume. Each job then gets temporary credentials instead of stored keys.
Yes, through a CodeConnections (formerly CodeStar Connections) source action. V2 pipelines can trigger on pushes or pull requests and filter on branches, file paths and Git tags.
Yes. With Encore, you link the GitHub repository and push. Encore builds and tests pull requests, provisions the infrastructure your code declares in your own AWS account, and deploys to Fargate or EKS on push to the configured branch.
Deploy to your cloud on AWS and Google Cloud
without managing infrastructure
Encore lets developers and agents define application infrastructure directly in code, then automatically provisions it from local development to production in your AWS or GCP account.