cdk-cost-analyzer 0.1.17 → 0.1.19

package/.kiro/specs/cdk-cost-analyzer-blog/blog-post-narrative.md

@@ -0,0 +1,240 @@
+# CDK Cost Analyzer: How I Learned to Stop Worrying and Love Infrastructure Costs
+
+## Background: My CDK Cost Problem
+
+I've been working with AWS CDK for a while now, and I love it. Define infrastructure in TypeScript, run `cdk deploy`, and boom—everything's provisioned. It's elegant, it's powerful, and it makes infrastructure feel like just another part of my codebase.
+
+But there's this one question that kept nagging me during every project: "How much is this going to cost?"
+
+At my current project, I'm building a new microservices platform. We're using ECS Fargate, Application Load Balancers, NAT Gateways—the usual suspects. My team lead kept asking about monthly costs, and honestly? I had no idea. I'd mumble something about "checking the AWS Pricing Calculator" and hope the conversation moved on.
+
+Here's the thing: budget constraints are real. When you're pitching a new feature to stakeholders, "I don't know what it'll cost" isn't a great answer. And when the monthly AWS bill arrives and it's $500 more than expected? That's a conversation nobody wants to have.
+
+## Here's Where My Problem Started
+
+So there I was, reviewing a pull request from a colleague. The code looked fine—adding a NAT Gateway to enable private subnet internet access. Standard stuff. I approved it, we merged it, deployed to production.
+
+Fast forward to the end of the month. Our AWS bill showed an extra $43 for... a NAT Gateway? I had to look it up. Turns out, NAT Gateways cost about $32 per month just for existing, plus data processing fees. Nobody mentioned this. Nobody knew.
+
+The worst part? This wasn't even a mistake. We needed that NAT Gateway. But I should have known about the cost before deployment, not after.
+
+## The Manual Approach (That I Hated)
+
+I tried doing this properly. For the next infrastructure change, I sat down with the CloudFormation template CDK generated and started manually calculating costs:
+
+1. Open the template, find all the resources
+2. Look up each service in the AWS Pricing Calculator
+3. Make assumptions about usage (how many Lambda invocations? how much S3 storage?)
+4. Add it all up in a spreadsheet
+
+This took me two hours. Two hours I could have spent actually building features. And I still wasn't confident in my numbers because I had to guess at usage patterns.
+
+The AWS Pricing Calculator is great, but it doesn't integrate with my workflow. I can't automatically check if my infrastructure changes increase costs. I can't enforce cost thresholds in CI/CD. I can't compare costs between different versions of my stack.
+
+There had to be a better way.
+
+## The Solution I Built
+
+That's when I started working on cdk-cost-analyzer. The idea was simple: analyze CloudFormation templates and calculate estimated monthly costs automatically. Query the AWS Pricing API for current pricing, apply reasonable usage assumptions, and give me a number I can actually work with.
+
+I wanted three things:
+
+**Single Template Analysis**: Just tell me what this stack will cost.
+
+**Diff Mode**: Show me the cost difference between two versions.
+
+**CI/CD Integration**: Catch cost increases automatically in my pipeline.
+
+### What It Supports
+
+Right now, the tool handles 13 AWS services—the ones I use most often:
+
+**Compute**: Lambda, EC2, ECS (both Fargate and EC2)
+
+**Storage**: S3
+
+**Database**: RDS (MySQL, PostgreSQL, Aurora, etc.) and DynamoDB
+
+**Networking**: NAT Gateway, ALB, NLB, VPC Endpoints
+
+**Content Delivery**: CloudFront
+
+**API Management**: API Gateway (REST, HTTP, WebSocket)
+
+**Caching**: ElastiCache
+
+It queries the AWS Pricing API for real, current pricing in your region. No hardcoded prices that go stale.
+
+## How I Use It
+
+### Installation
+
+I keep it simple:
+
+```bash
+# Global installation
+npm install -g cdk-cost-analyzer
+
+# Or just use npx
+npx cdk-cost-analyzer --help
+```
+
+### My First Analysis
+
+After synthesizing my CDK app, I ran:
+
+```bash
+npx cdk-cost-analyzer analyze cdk.out/MyStack.template.json
+```
+
+And got this:
+
+```text
+Total Monthly Cost: $89.43 USD
+Region: eu-central-1
+
+Cost Breakdown:
+- NAT Gateway:              $43.16 (48.3%)
+- Application Load Balancer: $25.55 (28.6%)
+- ECS Fargate Service:      $20.72 (23.2%)
+
+Total Resources: 36
+Supported Resources: 3
+Unsupported Resources: 33
+```
+
+That NAT Gateway? Nearly half my monthly cost. Suddenly, that $43 surprise from before made sense. And now I could see it before deploying.
+
+### The Game-Changer: Diff Mode
+
+This is where it gets really useful. Before merging any infrastructure PR, I run:
+
+```bash
+npx cdk-cost-analyzer compare \
+  cdk.out.before/MyStack.template.json \
+  cdk.out.after/MyStack.template.json
+```
+
+Output:
+
+```text
+Total Cost Delta: +$2.08
+
+ADDED RESOURCES:
+  • Lambda Function: +$2.08/month [medium confidence]
+    - 1,000,000 invocations per month
+    - 128MB memory allocation
+    - 1000ms average duration
+  
+  • DynamoDB Table: $0.00 [unknown - not yet supported]
+  • API Gateway: $0.00 [unknown - not yet supported]
+```
+
+Now when I review PRs, I can ask: "Is this $2 per month worth it?" instead of "What does this do?" It changes the conversation from technical implementation to business value.
+
+### Automating It in CI/CD
+
+I added this to my GitLab CI pipeline:
+
+```yaml
+cost-analysis:
+  stage: cost-analysis
+  image: node:18
+  before_script:
+    - npm install -g cdk-cost-analyzer
+  script:
+    - |
+      cdk-cost-analyzer pipeline \
+        --synth \
+        --cdk-app-path ./infrastructure \
+        --region us-east-1 \
+        --format markdown \
+        --post-to-gitlab
+  only:
+    - merge_requests
+```
+
+Now every merge request gets a cost analysis comment automatically. My team sees cost implications during code review, not after deployment.
+
+### Setting Cost Thresholds
+
+I configured thresholds to fail the pipeline if costs get out of hand:
+
+```yaml
+# .cdk-cost-analyzer.yml
+thresholds:
+  environments:
+    production:
+      warning: 25   # USD per month
+      error: 100    # Fails the pipeline
+    development:
+      warning: 100
+      error: 500
+```
+
+If someone tries to add infrastructure that increases production costs by more than $100/month, the pipeline fails. They need to justify it before we merge.
+
+### Customizing for My Usage
+
+The default assumptions didn't match my actual usage, so I customized them:
+
+```yaml
+# .kiro/specs/cdk-cost-analyzer-blog/blog-post-narrative.md
+region: eu-central-1
+assumptions:
+  natGateway:
+    dataProcessingGB: 500  # We process way more than the default
+  lambda:
+    monthlyInvocations: 5000000  # High traffic API
+    averageDurationMs: 200
+  alb:
+    newConnectionsPerSecond: 100
+    processedBytesGB: 2000
+```
+
+This gave me much more accurate estimates for my specific workload.
+
+## What I've Learned
+
+### Cost Visibility Changes Everything
+
+Knowing that a NAT Gateway costs $43/month before adding it changes the decision-making process. Maybe we don't need it. Maybe VPC endpoints are cheaper. Maybe we do need it, but at least we know what we're signing up for.
+
+### Diff Mode Transforms Code Review
+
+I used to review infrastructure PRs by reading the CDK code and trying to understand what resources would be created. Now I just look at the cost diff. If it says "+$50/month," I know to ask questions. If it says "+$2/month," I probably don't need to dig deep.
+
+### Automation Prevents Surprises
+
+Since adding this to CI/CD, we haven't had a single surprise cost increase. Every change is analyzed, every cost increase is visible, and nothing slips through.
+
+### Custom Assumptions Matter
+
+The default assumptions are reasonable, but they're not your assumptions. I spent an hour customizing mine based on CloudWatch metrics from our existing infrastructure. Now my estimates are much more accurate.
+
+### It's Not Perfect, But It's Better
+
+The tool doesn't support every AWS service. It doesn't include data transfer costs. It doesn't account for Reserved Instances or Savings Plans. But you know what? It's still way better than manually calculating costs or, worse, not calculating them at all.
+
+## Try It Yourself
+
+I've open-sourced the tool:
+
+- **GitHub**: [github.com/yvovanzee/cdk-cost-analyzer](https://github.com/yvovanzee/cdk-cost-analyzer)
+- **npm**: [npmjs.com/package/cdk-cost-analyzer](https://www.npmjs.com/package/cdk-cost-analyzer)
+
+Install it and analyze your infrastructure:
+
+```bash
+npx cdk-cost-analyzer analyze cdk.out/YourStack.template.json
+```
+
+If you find bugs or want to add support for more AWS services, PRs are welcome. I built this to solve my own problem, but I'm hoping it helps others too.
+
+## Final Thoughts
+
+I'm not saying you should obsess over every dollar of infrastructure cost. But you should know what you're spending. You should be able to answer when someone asks "How much will this cost?" And you should catch expensive changes before they hit production.
+
+CDK Cost Analyzer helps me do that. Maybe it'll help you too.
+
+Give it a try on your next CDK project. Let me know how it goes.

package/.kiro/specs/cdk-cost-analyzer-blog/blog-post.md

@@ -0,0 +1,456 @@
+# CDK Cost Analyzer: Understanding Your AWS Infrastructure Costs Before Deployment
+
+## Background
+
+Working with AWS CDK makes infrastructure deployment straightforward. You define your infrastructure in code, run `cdk deploy`, and AWS provisions the resources. However, one question consistently arises during development: "How much will this cost?"
+
+This question matters. Budget constraints are real, stakeholders need cost estimates, and unexpected infrastructure costs can derail projects. A NAT Gateway that costs $32 per month just for being active, an Application Load Balancer at $16 per month base cost, or an RDS instance that ranges from $50 to $500+ per month—these costs add up quickly.
+
+CDK abstracts infrastructure details effectively, but this abstraction hides cost implications. You might add a NAT Gateway to enable private subnet internet access without realizing the monthly cost impact. You could deploy an Application Load Balancer for a development environment when a simpler solution would suffice. These decisions, made without cost visibility, lead to budget surprises.
+
+## The Challenge
+
+CDK generates CloudFormation templates that define your infrastructure. While these templates specify every resource in detail, they provide no cost information. To estimate costs, you must:
+
+1. Identify each resource in the template
+2. Look up pricing for each service in your region
+3. Calculate monthly costs based on usage assumptions
+4. Sum the total across all resources
+
+This manual process is time-consuming and error-prone. The AWS Pricing Calculator helps, but it does not integrate with your CDK workflow. You cannot automatically check if infrastructure changes increase costs. You cannot enforce cost thresholds in your CI/CD pipeline. You cannot compare costs between different versions of your stack.
+
+Consider a specific scenario: You add a NAT Gateway to your VPC to enable private subnet internet access. You commit the change, create a pull request, and deploy to production. Only when the monthly AWS bill arrives do you discover the NAT Gateway costs approximately $43 per month—$32 for the hourly charge plus data processing fees. This cost might be justified, but you should know about it before deployment, not after.
+
+## Solution: CDK Cost Analyzer
+
+The cdk-cost-analyzer tool addresses this challenge by analyzing CloudFormation templates and calculating estimated monthly costs. The tool queries the AWS Pricing API for current, region-specific pricing and applies usage assumptions to generate cost estimates.
+
+### How It Works
+
+The tool operates in three modes:
+
+**Single Template Analysis**: Analyze one CloudFormation template to understand baseline infrastructure costs.
+
+**Diff Mode**: Compare two templates to identify cost changes between versions.
+
+**CI/CD Integration**: Automate cost analysis in your deployment pipeline with configurable cost thresholds.
+
+### Supported AWS Services
+
+The tool currently supports 13 AWS services across major categories:
+
+**Compute**:
+- AWS Lambda
+- Amazon EC2
+- Amazon ECS (Fargate and EC2)
+
+**Storage**:
+- Amazon S3
+
+**Database**:
+- Amazon RDS (MySQL, PostgreSQL, MariaDB, Oracle, SQL Server, Aurora)
+- Amazon DynamoDB
+
+**Networking**:
+- NAT Gateway
+- Application Load Balancer
+- Network Load Balancer
+- VPC Endpoint
+
+**Content Delivery**:
+- Amazon CloudFront
+
+**API Management**:
+- Amazon API Gateway (REST, HTTP, WebSocket)
+
+**Caching**:
+- Amazon ElastiCache (Redis, Memcached)
+
+The tool uses the AWS Pricing API to fetch current pricing data for your specified region, ensuring estimates reflect actual AWS pricing.
+
+## Getting Started
+
+### Installation
+
+Install the tool globally via npm or use npx to run it without installation:
+
+```bash
+# Global installation
+npm install -g cdk-cost-analyzer
+
+# Or use with npx (no installation required)
+npx cdk-cost-analyzer --help
+```
+
+### Prerequisites
+
+- Node.js 18 or later
+- AWS credentials configured (for AWS Pricing API access)
+- CloudFormation templates generated by CDK
+
+The tool requires AWS credentials to query the Pricing API. Configure credentials using environment variables, AWS CLI configuration, or IAM roles. The required IAM permissions are:
+
+```json
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Action": [
+        "pricing:GetProducts",
+        "pricing:DescribeServices"
+      ],
+      "Resource": "*"
+    }
+  ]
+}
+```
+
+### Basic Usage
+
+First, synthesize your CDK application to generate CloudFormation templates:
+
+```bash
+cd your-cdk-project
+npx cdk synth
+```
+
+Then analyze the generated template:
+
+```bash
+npx cdk-cost-analyzer analyze cdk.out/YourStack.template.json
+```
+
+### Example Output
+
+```text
+Total Monthly Cost: $89.43 USD
+Region: eu-central-1
+
+Cost Breakdown:
+- NAT Gateway:              $43.16 (48.3%)
+- Application Load Balancer: $25.55 (28.6%)
+- ECS Fargate Service:      $20.72 (23.2%)
+
+Total Resources: 36
+Supported Resources: 3
+Unsupported Resources: 33
+```
+
+### Interpreting Results
+
+The output shows:
+
+**Total Monthly Cost**: Estimated monthly cost for all supported resources in the template.
+
+**Cost Breakdown**: Individual resource costs sorted by expense, with percentage of total cost.
+
+**Resource Counts**: Total resources in the template, how many are supported by the tool, and how many are not yet supported.
+
+The example reveals that the NAT Gateway accounts for nearly half the monthly infrastructure cost. This information helps you make informed decisions about whether a NAT Gateway is necessary or if alternatives like VPC endpoints could reduce costs.
+
+## Practical Examples
+
+### Single Template Analysis
+
+Analyze a template to understand baseline costs:
+
+```bash
+npx cdk-cost-analyzer analyze demo/cdk.out/demo-dev.template.json
+```
+
+Output:
+
+```text
+Total Monthly Cost: $89.43 USD
+Region: eu-central-1
+
+Cost Breakdown:
+- NAT Gateway:              $43.16 (48.3%)
+  Hourly rate: $0.0520/hour × 730 hours = $37.96/month
+  Data processing: $0.0520/GB × 100 GB = $5.20/month
+
+- Application Load Balancer: $25.55 (28.6%)
+  Hourly rate: $0.0252/hour × 730 hours = $18.40/month
+  LCU charges: 25 new connections/sec, 3000 active connections/min
+
+- ECS Fargate Service:      $20.72 (23.2%)
+  vCPU: 0.25 vCPU × $0.04656/hour × 730 hours = $8.50/month
+  Memory: 0.5 GB × $0.00511/GB-hour × 730 hours = $1.87/month
+
+Total Resources: 36
+Supported Resources: 3
+Unsupported Resources: 33
+```
+
+The detailed breakdown shows pricing assumptions for each resource. The NAT Gateway cost includes both the hourly charge and data processing fees. The ALB cost includes the base hourly rate plus Load Balancer Capacity Unit (LCU) charges based on traffic assumptions.
+
+### Diff Mode: Comparing Infrastructure Changes
+
+Before deploying infrastructure changes, compare costs between versions:
+
+```bash
+npx cdk-cost-analyzer compare \
+  demo/cdk.out.1/demo-dev.template.json \
+  demo/cdk.out.2/demo-dev.template.json
+```
+
+Output:
+
+```text
+Total Cost Delta: +$2.08
+
+ADDED RESOURCES:
+  • Lambda Function: +$2.08/month [medium confidence]
+    - 1,000,000 invocations per month
+    - 128MB memory allocation
+    - 1000ms average duration
+  
+  • DynamoDB Table: $0.00 [unknown - not yet supported]
+  • API Gateway: $0.00 [unknown - not yet supported]
+  • 17 new resources total
+
+REMOVED RESOURCES:
+  None
+
+MODIFIED RESOURCES:
+  None
+```
+
+This comparison shows that adding a Lambda function increases monthly costs by approximately $2.08. While DynamoDB and API Gateway costs are not yet calculated, the tool identifies these resources so you can manually estimate their costs.
+
+Diff mode proves invaluable during code review. When reviewing a pull request that adds infrastructure, you can immediately see the cost impact. This visibility enables informed discussions about whether the cost is justified and whether alternatives exist.
+
+### CI/CD Integration
+
+Automate cost analysis in your deployment pipeline to catch cost increases before they reach production.
+
+#### GitLab CI Example
+
+```yaml
+stages:
+  - build
+  - cost-analysis
+  - deploy
+
+cost-analysis:
+  stage: cost-analysis
+  image: node:18
+  before_script:
+    - npm install -g cdk-cost-analyzer
+  script:
+    - |
+      cdk-cost-analyzer pipeline \
+        --synth \
+        --cdk-app-path ./infrastructure \
+        --region us-east-1 \
+        --format markdown \
+        --post-to-gitlab
+  only:
+    - merge_requests
+```
+
+This configuration:
+- Runs cost analysis on every merge request
+- Automatically synthesizes CDK templates
+- Posts results as a comment on the merge request
+- Provides cost visibility before merging changes
+
+#### GitHub Actions Example
+
+```yaml
+name: Cost Analysis
+
+on:
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  analyze-costs:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20.x'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Install CDK Cost Analyzer
+        run: npm install -g cdk-cost-analyzer
+
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: us-east-1
+
+      - name: Run cost analysis
+        run: |
+          cdk-cost-analyzer pipeline \
+            --synth \
+            --cdk-app-path ./infrastructure \
+            --region us-east-1 \
+            --format markdown > cost-report.md
+
+      - name: Comment PR
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const fs = require('fs');
+            const report = fs.readFileSync('cost-report.md', 'utf8');
+            
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: report
+            });
+```
+
+#### Cost Threshold Enforcement
+
+Configure cost thresholds to fail the pipeline if costs exceed defined limits:
+
+```yaml
+# .cdk-cost-analyzer.yml
+thresholds:
+  environments:
+    production:
+      warning: 25   # USD per month - warning only
+      error: 100    # USD per month - fails pipeline
+    development:
+      warning: 100
+      error: 500
+```
+
+When the cost increase exceeds the error threshold, the pipeline fails, preventing deployment until the cost increase is reviewed and approved.
+
+Benefits of CI/CD integration:
+
+- **Automatic cost checks**: Every infrastructure change is analyzed
+- **Cost visibility**: Team members see cost implications during code review
+- **Cost governance**: Enforce cost thresholds to prevent unexpected increases
+- **Cost awareness**: Developers consider costs when making infrastructure decisions
+
+### Custom Assumptions
+
+The tool uses default usage assumptions for cost calculations. Customize these assumptions to match your specific usage patterns:
+
+```yaml
+# .cdk-cost-analyzer.yml
+region: eu-central-1
+assumptions:
+  natGateway:
+    dataProcessingGB: 500  # Higher data processing than default
+  lambda:
+    monthlyInvocations: 1000000
+    averageDurationMs: 200
+  ecs:
+    taskCount: 4  # More tasks than default
+  alb:
+    newConnectionsPerSecond: 50
+    activeConnectionsPerMinute: 5000
+    processedBytesGB: 1000
+```
+
+Use the configuration file with the analyze command:
+
+```bash
+npx cdk-cost-analyzer analyze \
+  cdk.out/YourStack.template.json \
+  --config .cdk-cost-analyzer.yml
+```
+
+Custom assumptions provide more accurate cost estimates when your usage patterns differ significantly from the defaults.
+
+## Understanding Cost Estimates
+
+### Confidence Levels
+
+The tool assigns confidence levels to cost estimates:
+
+**High**: Based on actual AWS Pricing API data with minimal assumptions. Examples: EC2 instances with specified instance types, RDS instances with defined instance classes.
+
+**Medium**: Based on AWS Pricing API data with standard usage assumptions. Examples: Lambda functions, NAT Gateways, Load Balancers.
+
+**Low**: Estimated based on typical usage patterns with significant assumptions. Examples: ECS on EC2 (depends on underlying instance costs).
+
+**Unknown**: Resource type not yet supported by the tool.
+
+### Limitations
+
+Cost estimates are based on assumptions and have limitations:
+
+- **Usage patterns**: Actual costs depend on traffic, data transfer, and usage patterns
+- **Data transfer**: Most calculators do not include data transfer costs between regions or to the internet
+- **Reserved Instances**: Only on-demand pricing is calculated; Reserved Instance or Savings Plans discounts are not included
+- **Free Tier**: AWS Free Tier benefits are not calculated or deducted
+- **Tiered pricing**: Some services have tiered pricing that is simplified in the tool
+- **Unsupported resources**: Resources not yet supported by the tool are not included in cost estimates
+
+Despite these limitations, the tool provides valuable cost visibility for infrastructure decisions. Use the estimates as a starting point for cost discussions and budget planning.
+
+## Summary
+
+CDK Cost Analyzer provides cost visibility for AWS CDK infrastructure before deployment. The tool analyzes CloudFormation templates, queries the AWS Pricing API, and generates estimated monthly costs for your infrastructure.
+
+Key capabilities:
+
+- **Single template analysis**: Understand baseline infrastructure costs
+- **Diff mode**: Compare costs between infrastructure versions
+- **CI/CD integration**: Automate cost analysis in deployment pipelines
+- **Cost thresholds**: Enforce cost limits to prevent unexpected increases
+- **Custom assumptions**: Tailor cost estimates to your usage patterns
+
+The tool supports 13 AWS services across compute, storage, database, networking, content delivery, API management, and caching categories. While not all AWS services are supported, the tool covers the most common infrastructure components used in CDK applications.
+
+Use CDK Cost Analyzer when:
+
+- Planning new infrastructure deployments
+- Reviewing infrastructure changes in pull requests
+- Optimizing infrastructure costs
+- Enforcing cost governance in CI/CD pipelines
+- Communicating infrastructure costs to stakeholders
+
+Cost estimates are based on AWS Pricing API data and usage assumptions. Actual costs will vary based on your specific usage patterns, but the estimates provide valuable guidance for infrastructure decisions.
+
+## Lessons Learned
+
+Working with CDK Cost Analyzer has reinforced several important principles:
+
+**Cost visibility early prevents surprises later**: Understanding infrastructure costs during development enables better decisions. When you know a NAT Gateway costs $43 per month, you can evaluate whether it is necessary or if VPC endpoints provide a more cost-effective alternative.
+
+**Diff mode is invaluable for code review**: Seeing cost changes in pull requests transforms infrastructure review. Instead of asking "What does this change do?", you can ask "Is this $50 per month cost increase justified?" This shifts the conversation from technical implementation to business value.
+
+**CI/CD integration catches cost increases automatically**: Automated cost analysis in deployment pipelines prevents unexpected cost increases from reaching production. Cost thresholds enforce governance without requiring manual review of every change.
+
+**Custom assumptions enable accurate modeling**: Default assumptions provide reasonable estimates, but customizing assumptions to match your usage patterns improves accuracy. If your Lambda functions receive 10 million invocations per month instead of 1 million, custom assumptions reflect this reality.
+
+**Open source enables community contributions**: The tool is open source, allowing the community to add support for additional AWS services, improve pricing calculations, and fix issues. If a service you need is not supported, you can contribute the implementation.
+
+## Try It Yourself
+
+CDK Cost Analyzer is available on npm and GitHub:
+
+- **GitHub Repository**: [github.com/yvovanzee/cdk-cost-analyzer](https://github.com/yvovanzee/cdk-cost-analyzer)
+- **npm Package**: [npmjs.com/package/cdk-cost-analyzer](https://www.npmjs.com/package/cdk-cost-analyzer)
+- **Documentation**: See the GitHub repository README for detailed documentation
+
+Install the tool and analyze your CDK infrastructure:
+
+```bash
+npx cdk-cost-analyzer analyze cdk.out/YourStack.template.json
+```
+
+Contributions are welcome. If you encounter issues, have feature requests, or want to add support for additional AWS services, open an issue or submit a pull request on GitHub.
+
+Understanding infrastructure costs before deployment enables better decisions, prevents budget surprises, and promotes cost-aware development practices. Give CDK Cost Analyzer a try on your next CDK project.