AWS Builder Center

The Pragmatic Cloud Practitioner

A summary of the book "The Pragmatic Programmer" and how it applies to Cloud Practitioners as well.

Series: The Pragmatic Cloud Practitioner (2 articles)

  1. 1
    The Pragmatic Cloud Practitioner This article
Fullstack Developer

Intro

Even 25 years after it was first released, The Pragmatic Programmer by Andrew Hunt and David Thomas is still one of the most well-read books in software engineering. It's not a language or framework book – it's about mindset, craftsmanship, and habits. As someone put it, "In a world obsessed with frameworks, AI tools, and shiny tech—The Pragmatic Programmer reminds us that great engineering isn't about syntax. It's about mindset, habits, and craftsmanship."
So what do you get when you apply that pragmatic philosophy to the cloud? You realize the cloud isn't just "a place to run servers" – it's a programmable, dynamic environment where the same principles that make code great also make infrastructure great.
Here are four key concepts from the book, applied to AWS.



1. DRY (Don't Repeat Yourself) in the Cloud

The DRY principle: "Every piece of knowledge must have a single, unambiguous, authoritative representation within a system." This is much more than just avoiding copying and pasting code.
In AWS, we often see DRY violations across infrastructure, security, configuration, and deployment:
Domain
DRY Violation
Pragmatic Solution
Infrastructure
Copy-pastes CloudFormation or Terraform across environments
Use modules, nested stacks, and templates
Security
Scattered IAM policies and security group rules across accounts/VPCs
Centralize policy-as-code, use SCPs
Configuration
Hardcoded values in Lambda functions, EC2 user data
Use Parameter Store, Secrets Manager, or AppConfig
Deployment
Manual deployment procedures with undocumented steps
Fully automated CI/CD (CodePipeline/CodeBuild)
The ideal here: change a business rule or a configuration detail once, not 100 places.



2. Tracer Bullets Over Big Design Up Front

The book's advice: "Use Tracer Bullets to Find the Target." Instead of front-loading the design process across your architecture, build and deploy a thin, end-to-end slice of functionality that validates your core assumptions and integrations early. This isn't a disposable prototype – it's the skeleton of your final system.
How it can be applied in AWS:
Instead of architecting an entire microservices mesh with API Gateway, ECS, RDS, and SQS before you've written a single line of code, start with one Lambda function behind a basic API Gateway endpoint that reads from and writes to DynamoDB.
Deploy it and measure latency, cost, and user experience. If it hits your targets, add SQS for async processing. If not, maybe DynamoDB isn't the right fit and you need to swap it for RDS.
This approach rapidly builds your infrastructure, proves your integrations, and gives you a baseline to iterate on. "Tracer bullets show what you're hitting. This may not always be the target. You then adjust your aim until they're on target. That's the point," as the book put it.



3. Orthogonality: Shy Components, Independent Systems

The principle: "Eliminate Effects Between Unrelated Things." Orthogonal components are those that don't know or care much about each other. They are independent. The book calls this "writing shy code."
AWS service design itself is fundamentally orthogonal:
AWS Service
Why It's Orthogonal
S3
Stores objects independently of computation. You can swap out a web server or back-end compute (EC2, Lambda, Fargate) without touching S3
SQS/SNS
Decouples components. Senders don't care who receives their messages, and receivers don't know where messages originated
DynamoDB + DAX
You can add a caching layer on top of your DynamoDB tables without altering the application code itself
CloudFront
Adds an edge caching layer in front of your origin (S3, EC2, Lambda) without modifying the application or content source
This orthogonality in AWS relies on discipline in your code and architecture too. Ensure you:
  • Minimize shared mutable state across services (avoid NFS mounts; use object storage or key-value stores for shared state)
  • Avoid ambient dependencies (global variables, shared in-memory caches across independent processes)
  • Grant permissions explicitly through IAM roles, not embedded credentials
The benefit: upgrade, replace, or scale components in isolation without breaking the entire system.



4. Automate the Boring Stuff (and the Critical Stuff)

The mantra: "If you do something twice, script it. Automation scales your effectiveness." Repetitive, error-prone, manual processes should be scripted and automated. In the cloud, this is non-negotiable:
Task
AWS Automation
Infrastructure Provisioning
CloudFormation, CDK, Terraform – never click-ops
Deployment
CodePipeline and CodeDeploy (or equivalent CI/CD tools)
Testing
CodeBuild for automated unit tests, integration tests, and property-based tests
Security Patching
Systems Manager Patch Manager with automated scheduling
Cost Management
Budget alerts + scheduled Auto Scaling Group terminations or Lambda-based shutdown of non-prod
Backups
Automated RDS snapshots, EBS snapshots with retention
"Prefer repeatable scripts over tribal-knowledge commands." If your process relies on someone remembering a series of CLI invocations in order, you've failed.



Bonus: Communicate – Don't Just Code

The authors reminded us: "There's no point in having great ideas if you don't communicate them effectively." In the cloud, this means:
  • Document the why behind your architectural decisions (including trade-offs and abandoned approaches)
  • Use plain-text formats for scripts and configuration, as these formats tend to outlast vendor-specific solutions
  • Write clear READMEs for your infrastructure and application code, explaining how to deploy, test, and manage it. Think of English as just another part of your programming language
Writing is not a necessary evil; it is an integral part of engineering.



Conclusion: The Cloud Is Code

The Pragmatic Programmer's principles are evergreen and transcend language, framework, and decade. They are about clear thinking, ownership, and building systems that adapt.
In AWS, with its extensive and powerful API surface across every service, we have a fantastic platform for applying these principles. Applying DRY, orthogonality, tracer bullets, and automation isn't just good software engineering; it's the path to great cloud architecture.

Series: The Pragmatic Cloud Practitioner (2 articles)

  1. 1
    The Pragmatic Cloud Practitioner This article
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article