Java Apps on AWS Without the Headaches: Fast Builds, Cheap Deploys, No Kubernetes Let’s face it: the cloud has gotten out of hand. What used to be simple—deploying your Java app—has become a maze of slow builds, tedious deploys, and eye-watering AWS bills. But here’s the thing: it doesn’t have to be this way. Every minute you spend waiting on builds or wrestling with unnecessary cloud complexity is a minute you’re not building the features your customers actually care about. In this talk, I’ll show you how to go from a shiny new Java app to production in under 10 minutes—with fast builds, cheap deploys, and zero downtime. We’ll go deep into optimizing builds with Gradle (it’s time to leave Maven in the dust), parallelization strategies, and smarter caching mechanics that make your CI/CD pipelines fly. From there, we’ll review the dozen+ ways AWS lets you deploy apps and cut through the chaos to find the solutions that work best for lean, fast, cost-effective pipelines. Spoiler: ECS and EKS usually aren’t the answer. Oh, and I’ll even show you how AI tools like AWS Bedrock can help streamline your processes further, so you can automate what should already be automatic. This talk is for developers fed up with the cost, complexity, and friction of modern cloud setups—or those who long for the simplicity of the Heroku/Beanstalk/PCF days when deploying to the cloud wasn’t a headache. Whether you’re on AWS, Azure, or GCP, you’ll learn actionable, cloud-agnostic tips to build faster, deploy cheaper, and refocus on what matters most: delivering value to your users.

1. By: Victor Szoltysek
March 27 / 2025
Java Usergroup Meetup - Toronto
Fast Builds, Cheap Deploys, No
Kubernetes
JAVA ON AWS WITHOUT
THE HEADACHES

2. WHY YOU SHOULD LISTEN TO ME
(AT LEAST A LITTLE)
• 20+ years in Java and cloud — startups,
enterprises, Silicon Valley.
• Lots of time spent
fi
re
fi
ghting and
fi
xing what
doesn’t scale.
• AWS Gold Jacket holder — all AWS certs, one of
~5 in Canada.
• Advice is for the 95% of Java shops in Toronto
— not Net
fl
ix.
• Generalizations? Yes. But you should still
follow them.
VICTOR
SZOLTYSEK

3. YOU WERE PROMISED THIS WOULD BE EASIER
• CI/CD was supposed to be simple. Cloud was supposed to
be cheap. Kubernetes was supposed to help.
• Instead, builds are slow, deploys are painful, and cloud
costs are out of control.
• Somewhere along the way, we forgot the point: Delivering
value quickly, without unnecessary complexity.
CI/CD, Cloud, and Kubernetes Have Let You Down

4. IT CAN BE CHEAP. IT CAN BE EASY. IT CAN BE FAST.
• Stop chasing trends and buzzwords you don’t need.
• Stop maintaining infrastructure you don’t need.
• $10/month AWS costs for a Java apps is possible.
• 15-minute Lead Time to Production is possible.
• You just need to drop the obsession with cargo culting and
buzzwords — and focus on what actually delivers value.
You Just Need To Focus on What Matters

5. HOW FAST CAN YOU ACTUALLY GET TO PROD?

6. HOW FAST CAN YOU ACTUALLY GET TO PROD?
• Congrats on your pipelines. But can you get a code change live in under 15 minutes?
• “We deploy on Fridays at 9pm” = broken.
• If you’re scared of production, your process sucks.
• Lead Time to Deploy is the only CI/CD metric that matters. Everything else is cargo cult.
• You don't
fi
x delivery speed by throwing buzzwords at it — you pro
fi
le, you experiment,
and you iterate.
• So how do we get there ? …
“CI/CD” Is Meaningless if Feedback Is Hours Away.

7. USE ALL YOUR CAPACITY
• Use Maven or Gradle Wrapper — your Java build should run on any agent. It shouldn’t
need Python, Ruby, or a PhD in DevOps.
• Modern laptops have 16 CPUs. So do your runners. Why are you still building with one?
• In Maven use -T1C
fl
ag, in Gradle use —parrallel
fl
ag.
• Parallel tests, parallel steps, parallel builds — yes, all of it. Pretty pipelines don’t ship
features. Fast ones do.
• If your build system is single-threaded in 2025, that’s not technical debt — that’s
sabotage.
Why Do Your Agents Sit Idle While Builds Take Forever?

8. STOP DOING POINTLESS WORK
• Don’t build on README edits. Don’t build on random document changes.
• You don’t need containers just to deploy a JAR. Seriously.
• A fat JAR is 30MB. A container is 300MB, plus layers, registries, signing, scanning...
• Strip out tests that don’t add value — blindly chasing coverage numbers only adds
noise.
• Code coverage can be gamed. Code Coverage will be gamed. The real goal is fast
feedback: detect issues quickly,
fi
x them even faster.
Your Build Is Slow Because You’re Doing 5x More Than You Need To.

9. DON'T REPEAT YOURSELF
• One artifact. One build. Promote it.
• PR build is redundant if you're already synced with trunk.
• No snapshots. One build for all environments. Every build is a release candidate.
• Use dependency caching to avoid rebuilding the world every time.
• Use Gradle’s incremental builds and build caching (especially in CI).
• Gradle gives you speed, caching, and
fl
exibility. Maven gives you XML.
Stop Wasting Time Doing the Same Work Over and Over.

10. SLIM DOWN YOUR BUILD ARTIFACTS
• Stop using containers for “hello world.”
• Consider lighter alternatives like Micronaut or Quarkus.
• Consider GraalVM — native builds are a cheat code for performance, but
not always worth it.
• Clean out your pom.xml. You don’t need six logging libraries.
• If your Lambda takes 30 seconds to cold start, look at AWS Lambda Layers.
You Could Run This on a Raspberry Pi, but Your Docker Image Needs a GPU.

11. MAKE DEPLOYMENTS EASY AND DAYTIME-FRIENDLY
• One-line automated deploys. No rituals. No playbooks. No ceremonies.
• Include deploy scripts as part of your codebase — easier to debug and
version (Gradle).
• Allow developers to deploy from their local machines (lower environments).
• Zero-downtime deploys are a solved problem — rolling, blue/green,
whatever.
• Rollbacks should be instant. Not a crisis plan. A button.
If Your Deploys Need a War Room, You’ve Already Failed.

12. STOP RELYING ON MANUAL GATES
• Mandatory PRs for every single change? Even spelling
fi
xes? Stop.
• Manual QA signo
ff
s? XCAB/TCAB meetings? Stop pretending meetings ship
code. They were cute in 2006.
• Security, SBOMs, tests — run them in parallel, automatically, and early.
• Use CODEOWNERS to assign ownership clearly, not bureaucratically.
• Want real quality? Make your teams own their stu
ff
. Embedded QA,
embedded DevOps, “you build it, you run it.” The end.
You’re Not Improving Quality — You’re Just Slowing Everyone Down.

13. STOP THINKING IN TERMS OF PIPELINES
• Pipelines are the new XML — bloated, overcomplicated, and revered for no reason.
• Minimize logic in pipelines — keep it in your build scripts where it's easier to debug,
version, and reuse.
• YAML is not a strategy. Bespoke plugins are not velocity. Reusability doesn’t equal speed.
• Most pipelines serialize things that should run in parallel.
• Think in terms of dependency trees and not pipelines.
• End of the day: does this get value to users faster? If not, it’s noise.
It's the New Cargo Cult.

14. BE CAREFUL WITH INTERNAL DEVOPS FRAMEWORKS
• If your “platform” requires a wiki to understand, you’ve already failed.
• Developers don’t need a golden path — they need golden guardrails.
• GitHub Actions is dead simple. Let devs de
fi
ne their own work
fl
ows.
• Mandates kill
fl
exibility. If your tool requires onboarding, it’s too complex.
• Teams move faster when they own their build and deploy lifecycle — 'you
build it, you run it' works here too.
More Often Than Not They Make Things Worse

15. SUMMARY: WHAT YOU SHOULD BE DOING:
• Use All Your Capacity
• Stop Doing Pointless Work
• Stop Building the Same Thing Twice
• Slim Down Your Build Artifacts
• Make Deployments Easy and Daytime-Friendly
• Stop Relying on Manual Gates
• Stop Thinking in Terms of Pipelines
• Be Careful With Internal DevOps Frameworks

16. HOW CHEAP CAN YOU ACTUALLY RUN YOUR APP?

17. HOW CHEAP CAN YOU ACTUALLY RUN YOUR APP?
• You’re probably spending more on engineers managing complexity
than on actual compute.
• The two biggest costs in cloud: what you pay, and what time you waste.
• If your simple CRUD app dev environment has $1,000/month AWS bill
and an entire DevOps team to manage, you're probably doing it wrong.
• You can run Java apps in the cloud for $10/month with minimal
overhead. Seriously.
Cloud Cost Isn’t Just About Dollars — It’s About Wasted Time.

18. THERE ARE TOO MANY WAYS TO RUN CODE ON AWS

19. THERE ARE TOO MANY WAYS TO RUN CODE ON AWS
Picking the Right AWS Compute Service Shouldn’t Feel Like a BuzzFeed Quiz.
Amazon EC2 AWS Lambda
Amazon Lightsail
AWS Elastic
Beanstalk
AWS App
Runner
AWS Batch
Amazon EKS
Amazon ECS
AWS Fargate
Etc ..

20. ELASTIC COMPUTE CLOUD (EC2)
• You manage the OS, the patches, and the scaling.
• Great
fl
exibility, terrible simplicity.
• Not cost-optimized unless you tune it manually.
• Undi
ff
erentiated heavy lifting: o
ff
loaded entirely to
you.
The OG. Still Solid — and Still Way Too Low-Level.

21. ELASTIC KUBERNETES SERVICE (EKS)
• Huge operational overhead for questionable ROI.
• You’ll need to manage pods, YAML, Helm charts, and pain.
• Requires ECR, IAM gymnastics, and observability setup.
• You’re on the hook for everything from networking to node groups.
• Undi
ff
erentiated heavy lifting: basically all of it, plus you get to
manage Kubernetes too.
Kubernetes: a Solution Looking for Your Problem.

22. ELASTIC CONTAINER SERVICE (ECS)
• Requires Docker
fi
le, Task De
fi
nitions, Service
con
fi
gs, etc.
• You manage scaling, logs, registry, and networking.
• Still tightly coupled to AWS-only patterns.
• Undi
ff
erentiated heavy lifting: still signi
fi
cant.
Slightly Easier Than EKS, but Still Too Much Ceremony.

23. APP RUNNER
• PaaS feel with container
fl
exibility.
• Autoscaling, HTTPS, and monitoring built-in.
• Still requires you to build and manage Docker containers — no magic here.
• Regional limitations (not in Canada... yet).
• Undi
ff
erentiated heavy lifting: low/moderate — better than ECS, but not
exactly push-button.
Almost Perfect — Except It’s Missing in Canada.

24. LAMBDA
• Cold starts time and 15 minute run time limits.
• Doesn’t play nice with typical Java / Spring Boot dev.
• Great for short bursts, not for long-running services.
• Easy to end up with dozens of tiny functions and tangled
orchestration.
• Undi
ff
erentiated heavy lifting: low, but constraints are high.
Serverless Magic — Until You Try To Run Java.

25. ELASTIC BEANSTALK
• AWS’s answer to Heroku/PCF — dead simple: “here’s my JAR, run it.”
• Supports JDK, .NET, Node.js, Python, GO, PHP, Ruby — and even Docker (including multi-
container setups).
• Autoscaling, monitoring, networking and blue/green deploys are built-in.
• Uses EC2 under the hood but wraps it with all the right guardrails.
• It’s dead simple — which means consultants, vendors, and platform teams can’t upsell
you.
• Undi
ff
erentiated heavy lifting: nearly eliminated.
The Most Underrated Service in the AWS Ecosystem.
The Sweet Spot for Most Java Teams.

26. S3 + CLOUDFRONT
• Ultra cheap, ultra fast, in
fi
nitely scalable.
• You don’t need Node.js + ECS to serve a React app — stop
overengineering.
• Just drop your build artifacts and ensure correct cache headers.
• Undi
ff
erentiated heavy lifting: zero — as long as you’re cool with
o
ff
loading compute to your users’ laptops.
Best Answer for Static Content. Period.

27. REDUCING COSTS

28. REDUCING COSTS
• Tag everything, track everything — from day one.
• Give teams real visibility into what they’re spending.
• Treat costs like bugs: if it slips, it spreads.
• Budget alerts + AWS Cost Anomaly Detection = instant red
fl
ags.
• Use AWS Cost Explorer and AWS Budgets to proactively manage and forecast
spend.
• Celebrate teams that reduce cost without reducing quality.
Adopt a Cost-First Engineering Mindset

29. RIGHT-SIZE YOUR RESOURCES
• Most services don’t need multi-AZ redundancy.
• Dev/Test can run on t3.micro just
fi
ne.
• Use AWS Compute Optimizer to auto-tune.
• Use Graviton (ARM) for even cheaper compute.
• Spot, Reserved, On-Demand, and Savings Plans exist — use them
like a grown-up.
You’re Over-Provisioned and You Know It.

30. STOP PAYING FOR THINGS YOU DON’T NEED
• Monoliths are cheaper. Microservices multiply cost, complexity, and
failure modes.
• Containers come with hidden costs — ECR, K8s, orchestration, startup lag.
• Serverless isn’t magic. It only saves money with erratic tra
ff
ic.
• You likely don’t need: Service Mesh, Service Discovery, Envoy, Istio,
AppCon
fi
g, Sidecars, Step Functions, or 17 types of logs.
• Keep it boring. Keep it simple. Save money. Sleep better.
You’re Not Net
fl
ix. You Don’t Need 50 Microservices and 8 Clusters.

31. CLEAN UP YOUR DATA SPRAWL
• Audit and delete old S3 buckets, snapshots, and AMIs.
• Use lifecycle policies for automatic cleanup.
• Glacier and Intelligent-Tiering help — but verify they're con
fi
gured
right.
• Don’t hoard logs, backups, and exports "just in case."
• Kill orphaned resources that nobody owns — you're tagging right?
Storage Creep Is Real — and Expensive.

32. LOG LESS, OBSERVE SMARTER
• Prefer metrics over verbose logs — especially in lower
environments.
• Log exceptions, not method calls like “entering method foo()."
• Use structured logs for fast indexing and insights.
• Too many logs = too many bills.
• Disable debug logs in prod unless actively troubleshooting.
Verbose Logging Doesn’t Help — It Just Adds Noise and Bills.

33. SUMMARY: WHAT YOU SHOULD BE DOING
• Use Elastic Beanstalk for traditional Java workloads — keep it
simple, keep it cheap.
• Use S3 + CloudFront for static sites and SPAs — fast, global, and
dirt cheap.
• Adopt a Cost-First Engineering Mindset
• Right-Size Your Resources
• Stop Paying for Things You Don’t Need
• Clean Up Your Data Sprawl
• Log Less, Observe Smarter

34. THE AI ADVANTAGE

35. THE AI ADVANTAGE
• AI coding tools (GitHub Copilot, Cursor, ChatGPT) are now table stakes.
• Modern ChatGPT has DeepResearch, IntelliJ integration, and team-focused
work
fl
ows — this isn’t just autocomplete anymore.
• Not giving devs access is like not giving them StackOver
fl
ow in 2010.
• They reduce friction, improve velocity, and unlock
fl
ow.
• Startups using AI are outpacing you. Enterprises adopting AI are cutting
time-to-delivery by 30%+.
AI Is Now a Baseline Expectation, Not a Luxury

36. AI ISN’T JUST CODE GENERATION
• Generate test cases and mocks.
• Explain error messages, stack traces.
• Draft pipeline YAML, IAM policies, and more.
• Brainstorm architectures, unblock solutioning, explore edge cases.
• Wrangle awful regex until it stops crying.
• Generate cover letters for TPS reports — with just the right amount of fake
enthusiasm.
Automate the Repetitive, Accelerate the Valuable

37. AMAZON DEVOPS GURU
• Automatic detection of anomalous behavior.
• Root cause analysis + recommendations.
• Integrated with CloudWatch, X-Ray, and more.
• Great
fi
t for ops-lite teams that don’t have time to dig
through dashboards.
AI-Powered Insights to Spot Issues Before Your Users Do.

38. AMAZON BEDROCK
• Access to top foundational models (Anthropic, Meta, Amazon
Titan).
• Fully managed + integrated with other AWS services.
• Use it for internal tools, chatbots, code generation, customer
support.
• Real value-add for orgs that want AI without spinning up GPUs.
Use LLMs Without Managing Infrastructure.

39. FINAL POINTS

40. FINAL POINTS
• Fast builds → Use all your cores/agents. Don’t rebuild nonsense.
• Cheap deploys → Beanstalk, not Kubernetes. Monoliths are
fi
ne.
• Less pain → Drop the cargo cult. Embrace boring.
• Competitive edge → Give every dev AI tools. Today
• Impact wins → Measurable improvements beat trendy stacks.
• The real goal → Faster delivery, better quality, lower cost. Full stop.
What Actually Works in 2025

41. victor_szoltysek@mac.com
www.victorszoltysek.com
Hiring for :
Cloud Architects
DevOps
.. reach me by email.