diff --git a/README.md b/README.md
index cacfe089..55a31860 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
- develop for local, deploy for the cloud
+ Terraform/CDK alternative designed for developers
@@ -10,221 +10,107 @@
[](https://github.com/klothoplatform/klotho/actions/workflows/prettier.yaml)
[](https://github.com/klothoplatform/klotho/actions/workflows/lint.yaml)
[](https://github.com/CloudCompilers/klotho/actions/workflows/govulncheck.yaml)
-[](https://raw.githack.com/wiki/klothoplatform/klotho/coverage.html)
-
-Klotho is an open source tool that transforms plain code into cloud native code.
-
-Klotho allows you to quickly and reliably add cloud functionality to your application with minimal modification to your code. In most cases, this is just a handful of klotho annotations.
-
-It adds 3 main in-code cloud capabilities:
-
-- **`expose`** web APIs to the Internet
-- **`persist`** multi-modal data into different types of databases
-- **`static_unit`** package static assets and upload into a CDN for distribution
-
-## Table of Contents
-
-- [Why?](#why)
-- [Adaptive Architectures](#adaptive-architectures)
-- [Infrastructure-from-Code](#infrastructure-from-code)
-- [Installation](#installation)
-- [IDE Plugins & Extensions](#ide-plugins--extensions)
-- [Getting Started](#getting-started)
-- [Example usage](#example-usage)
-- [Additional Resources](#additional-resources)
-- [Language Support](#language-support)
-- [Cloud Providers](#cloud-providers)
-- [Developing](#developing)
-
-## Why?
-
-Klotho is designed to absorb the complexity of building cloud applications, enabling everyone in large-scale organizations and teams to hobbyist developers to write and operate cloud applications at a fraction of the effort.
-
-Its design principles are an outcome of industry collaborations focused on mid-sized companies and fast growing startups.
-## Adaptive Architectures
-
-Klotho builds on a new architecture called [Adaptive Architectures](https://www.youtube.com/watch?v=GHt3FAEDfII&t=40392s).
-
-
-
-It's a superset of monoliths, microservices and serverless architectures, combining their benefits like a stellar developer experience, immediate productivity, scalability and autonomy of development and deployment as well as a spectrum of NoOps to FullOps. It also introduces a host of [new capabilities](https://klo.dev/) that have been out of reach do to their implementation complexity.
-
-## Infrastructure-from-Code
-
-Klotho is part of a new generation of cloud tools that implements Infrastructure-from-Code (IfC), a process to automatically create, configure and manage cloud resources from the existing software application's source code without having to describe it explicitly.
-
-By annotating the clients, SDKs or language constructs used in the code with Klotho capabilities, they are automatically created, updated and wired into the application.
-
-
-
- 
-
- Exposing a Python FastAPI to the internet with the Klotho klotho::expose capability. View for NodeJS, Go
-
-
-
-
-
- 
-
- Persisting Redis and TypeORM instances in NodeJS with the the Klotho klotho::persist capability. View for Python, Go (soon)
-
-
-
-Klotho ensures that developers/operators are able to select and adapt the underlying technologies even after their initial setup.
-
-## Installation
-
-To install the latest Klotho release, run the following (see [full installation instructions](https://klo.dev/docs/download-klotho) for additional installation options):
-
-Mac:
-
-```sh
-brew install klothoplatform/tap/klotho
-```
-
-Linux/WSL2:
-
-```sh
-curl -fsSL "https://github.com/klothoplatform/klotho/releases/latest/download/klotho_linux_amd64" -o klotho
-chmod +x klotho
+[](https://raw.githack.com/wiki/klothoplatform/klotho/coverage.html)
+[](https://github.com/klothoplatform/klotho/releases)
+[](https://github.com/klothoplatform/klotho/blob/main/LICENSE)
+
+## What is Klotho?
+Klotho is a developer-centric cloud infra-as-code deployment tool with high level constructs. It lets you think in terms of containers, functions, APIs and databases and combining them freely.
+
+### Example Klotho infra.py
+
+infra.py
+
+```python
+import os
+from pathlib import Path
+
+import klotho
+import klotho.aws as aws
+
+# Create the Application instance
+app = klotho.Application(
+ "my-sample-app",
+ project="my-project",
+ environment="default",
+ default_region="us-west-2",
+)
+
+dir = Path(__file__).parent.absolute()
+
+# Create a dynamodb instance with 2 indexed attributes
+dynamodb = aws.DynamoDB(
+ "my-dynamodb",
+ attributes=[
+ {"Name": "id", "Type": "S"},
+ {"Name": "data", "Type": "S"},
+ ],
+ hash_key="id",
+ range_key="data"
+)
+
+# Create a lambda function that reads in code and deploys it as a zip file
+my_function = aws.Function(
+ "my-function",
+ handler="handler.handler",
+ runtime="python3.12",
+ code=str(dir),
+)
+
+# Bind the dynamodb instance to the lambda function
+my_function.bind(dynamodb)
+
+# Create an ECS container
+my_container = aws.Container(
+ "my-container",
+ dockerfile=str(dir / "container" / "Dockerfile"),
+ context=str(dir),
+)
+
+# Create a Postgres instance with plain text password
+my_postgres = aws.Postgres(
+ "my-postgres",
+ username="admin",
+ password="password123!",
+ database="mydb",
+)
+
+# Bind the postgres instance to the container
+my_container.bind(my_postgres)
+
+# Create an API Gateway instance
+api = aws.Api("my-api")
+
+# Bind the lambda function to the API Gateway on the /function route
+api.route(
+ routes: [
+ RouteArgs(path="/function", method="ANY")
+ ], my_function
+)
+
+# Bind the container to the API Gateway on the /container route
+api.route(
+ routes: [
+ RouteArgs(path="/container", method="ANY")
+ ], my_container
+)
```
-
-## IDE Plugins & Extensions
-
-Get syntax highlighting and snippets for Klotho annotations in your favorite IDE.
-
-- [Visual Studio Code](https://github.com/klothoplatform/Klotho-vscode)
-- Intellij IDEA (coming soon)
+
## Getting Started
+To get started with Klotho, visit our [documentation](https://klo.dev/docs-k2/) and follow the guides to quickly set up your environment.
-The quickest way to get started is with the getting started tutorial for [Javascript/Typescript](https://klo.dev/docs/tutorials/your_first_klotho_app), [Python](https://klo.dev/docs/tutorials/your_first_klotho_app_python) and Go (soon).
-
-## Example usage
-
-### Clone the sample app
-
-Clone our sample apps git repo and install the npm packages for the [js-my-first-app](https://github.com/KlothoPlatform/sample-apps/tree/main/js-my-first-app) app:
-
-```sh
-git clone https://github.com/KlothoPlatform/sample-apps.git
-cd sample-apps/js-my-first-app
-npm install
-```
-
-### Logging in
-
-First log in to Klotho. This shares telemetry data for compiler improvements:
-
-```sh
-klotho --login
-```
-
-### Compile with Klotho
-
-Now compile the application for AWS by running `klotho` and passing `--provider aws` as an argument on the command line.
-
-```sh
-klotho . --app my-first-app --provider aws
-```
-
-Will result in:
-
-```sh
-██╗ ██╗██╗ ██████╗ ████████╗██╗ ██╗ ██████╗
-██║ ██╔╝██║ ██╔═══██╗╚══██╔══╝██║ ██║██╔═══██╗
-█████╔╝ ██║ ██║ ██║ ██║ ███████║██║ ██║
-██╔═██╗ ██║ ██║ ██║ ██║ ██╔══██║██║ ██║
-██║ ██╗███████╗╚██████╔╝ ██║ ██║ ██║╚██████╔╝
-╚═╝ ╚═╝╚══════╝ ╚═════╝ ╚═╝ ╚═╝ ╚═╝ ╚═════╝
-
-Adding resource input_file_dependencies:
-Adding resource exec_unit:main
-Found 2 route(s) on server 'app'
-Adding resource gateway:pet-api
-Adding resource persist_kv:petsByOwner
-Adding resource topology:my-first-app
-Adding resource infra_as_code:Pulumi (AWS)
-```
-
-The cloud version of the application is saved to the `./compiled` directory, and has everything you need to deploy, run and operate the application.
-
-### Examine the result
-
-As part of the compilation, Klotho generates a high-level topology diagram showing the cloud resources that will be used in your application's cloud deployment and their relationships.
-
-Open `./compiled/my-first-app.png` to view the application's topology diagram:
-
-
-
-