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)
- 1The Pragmatic Cloud Practitioner This article
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)
- 1The Pragmatic Cloud Practitioner This article
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article