• GPU-capable batch job for image classification using TensorFlow.
• Upload a .zip of images to the input S3 bucket — the job automatically classifies them using a pre-trained EfficientNet model and saves results to the output bucket.
• Uses spot instances for up to 90% cost savings. Perfect as a starting point for any ML batch processing workload.
• This project includes a pre-configured stacktape.yml configuration. The configured infrastructure is described in the stack description section

1. AWS account. If you don't have one, create new account here.

2. Stacktape account. If you don't have one, create new account here.

3. Stacktape installed.

iwr https://installs.stacktape.com/windows.ps1 -useb | iex

curl -L https://installs.stacktape.com/linux.sh | sh

curl -L https://installs.stacktape.com/macos.sh | sh

curl -L https://installs.stacktape.com/macos-arm.sh | sh

To initialize the project, use

stacktape init --starterId tensorflow-image-classification

• Install your projects dependencies. The recommended way is to use Virtual environment.

The deployment will take ~5-15 minutes. Subsequent deploys will be significantly faster.

stacktape deploy --projectName <<project-name>> --stage <<stage>> --region <<region>>

stacktape codebuild:deploy --stage <<stage>> --region <<region>> --projectName <<project-name>>

After a successful deployment, some information about the stack will be printed to the terminal (URLs of the deployed services, links to logs, metrics, etc.).

• Upload a .zip file containing images to the input bucket (bucket name is printed after deploy). You can use the included pictures/test-pictures.zip or your own images.

  aws s3 cp pictures/test-pictures.zip s3://<INPUT_BUCKET_NAME>/test-pictures.zip

• The batch job triggers automatically on upload. Classified images appear in the output bucket, organized into folders by predicted class.
• Monitor job progress in the AWS Batch console or CloudWatch Logs.

• Stacktape deployments use AWS CloudFormation under the hood. It brings a lot of guarantees and convenience, but can be slow for certain use-cases.

• To speed up the deployment, you can use the --hotSwap flag which avoids using Cloudformation.

• Hotswap deployments work only for source code changes (for lambda function, containers and batch jobs) and for content uploads to buckets.

• If the update deployment is not hot-swappable, Stacktape will automatically fall back to using a Cloudformation deployment.

stacktape deploy --hotSwap --stage <<stage>> --region <<region>> --projectName <<project-name>>

• If you no longer want to use your stack, you can delete it.
• Stacktape will automatically delete every infrastructure resource and deployment artifact associated with your stack.

stacktape delete --stage <<stage>> --region <<region>>

Stacktape uses a simple stacktape.yml configuration file to describe infrastructure resources, packaging, deployment pipeline and other aspects of your project.

You can deploy your project to multiple environments (stages) - for example production, staging or dev-john. A stack is a running instance of an project. It consists of your application code (if any) and the infrastructure resources required to run it.

The configuration for this project is described below.

• Every resource must have an arbitrary, alphanumeric name (A-z0-9).
• Stacktape resources consist of multiple underlying AWS or 3rd party resources.

Two S3 buckets handle the data pipeline:

• inputBucket — upload .zip archives of images here to kick off classification.
• outputBucket — the batch job writes classified images here, organized into folders by predicted class.

Both use the default bucket configuration.

inputBucket:
  type: bucket

outputBucket:
  type: bucket

The classifier runs as a GPU-capable batch job using spot instances for up to 90 % cost savings.

• S3 event trigger — an s3:ObjectCreated event on the input bucket (filtered to .zip suffix) starts the job automatically. No polling, no cron — just upload and go.
• Container packaging — uses a custom Dockerfile based on the TensorFlow image. Stacktape builds the image and pushes it to a managed ECR repository. You can also use other packaging types.
• connectTo — listing inputBucket and outputBucket in connectTo makes Stacktape automatically create the required IAM permissions and inject environment variables (bucket names, ARNs) into the container. No manual policy writing needed.
• Resources & spot — cpu and memory define the instance size AWS provisions on demand. Setting useSpotInstances: true opts into spot capacity, cutting costs significantly for fault-tolerant ML workloads.
• Swap the model — while this starter uses TensorFlow + EfficientNet, you can replace it with any ML framework (PyTorch, JAX, etc.) by changing the Dockerfile and source code. The infrastructure stays the same.

classifierJob:
  type: batch-job
  properties:
    container:
      packaging:
        type: custom-dockerfile
        properties:
          buildContextPath: ./
    resources:
      cpu: 2
      memory: 14000
    useSpotInstances: true
    connectTo:
      - inputBucket
      - outputBucket
    events:
      - type: s3
        properties:
          bucketArn: $ResourceParam('inputBucket', 'arn')
          s3EventType: s3:ObjectCreated:*
          filterRule:
            suffix: .zip