diff --git a/spring-cloud-function-adapters/spring-cloud-function-adapter-aws/README.adoc b/spring-cloud-function-adapters/spring-cloud-function-adapter-aws/README.adoc
index ebe03bb3e..a1f93459c 100644
--- a/spring-cloud-function-adapters/spring-cloud-function-adapter-aws/README.adoc
+++ b/spring-cloud-function-adapters/spring-cloud-function-adapter-aws/README.adoc
@@ -6,4 +6,97 @@ Edit the files in the src/main/asciidoc/ directory instead.
 
 This project provides an adapter layer for a Spring Cloud Function application onto AWS Lambda. You can write an app with a single `@Bean` of type `Function`, `Consumer` or `Supplier` and it will be deployable in AWS if you get the JAR file laid out right. The best way to make it work is to include `spring-cloud-function-context` as a dependency, but not the higher level adapters (e.g. `spring-cloud-function-stream`).
 
-Unresolved directive in aws-readme.adoc - include::adapters/aws-intro.adoc[]
\ No newline at end of file
+The adapter has a couple of generic request handlers that you can use. The most generic is `SpringBootStreamHandler`, which uses a Jackson `ObjectMapper` provided by Spring Boot to serialize and deserialize the objects in the function. There is also a `SpringBootRequestHandler` which you can extend, and provide the input and output types as type parameters (enabling AWS to inspect the class and do the JSON conversions itself).
+
+If your app has more than one `@Bean` of type `Function` etc. then you can choose the one to use by configuring `function.name` (e.g. as `FUNCTION_NAME` environment variable in AWS). The functions are extracted from the Spring Cloud `FunctionCatalog` (searching first for `Function` then `Consumer` and finally `Supplier`).
+
+== Notes on JAR Layout
+
+You don't need the Spring Cloud Function Web or Stream adapter at runtime in Lambda, so you might
+need to exclude those before you create the JAR you send to AWS. A Lambda application has to be
+shaded, but a Spring Boot standalone application does not, so you can run the same app using 2
+separate jars (as per the sample). The sample app creates 2 jar files, one with an `aws`
+classifier for deploying in Lambda, and one executable (thin) jar that includes `spring-cloud-function-web`
+at runtime. Spring Cloud Function will try and locate a "main class" for you from the JAR file
+manifest, using the `Start-Class` attribute (which will be added for you by the Spring Boot
+tooling if you use the starter parent). If there is no `Start-Class` in your manifest you can
+use an environment variable or system property `MAIN_CLASS` when you deploy the function to AWS.
+
+If you are not using the functional bean definitions but relying on Spring Boot's auto-configuration,
+then additional transformers must be configured as part of the maven-shade-plugin execution.
+
+[source, xml]
+----
+<plugin>
+	<groupId>org.apache.maven.plugins</groupId>
+	<artifactId>maven-shade-plugin</artifactId>
+	<dependencies>
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-maven-plugin</artifactId>
+		</dependency>
+	</dependencies>
+	<configuration>
+		<createDependencyReducedPom>false</createDependencyReducedPom>
+		<shadedArtifactAttached>true</shadedArtifactAttached>
+		<shadedClassifierName>aws</shadedClassifierName>
+		<transformers>
+			<transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
+				<resource>META-INF/spring.handlers</resource>
+			</transformer>
+			<transformer implementation="org.springframework.boot.maven.PropertiesMergingResourceTransformer">
+				<resource>META-INF/spring.factories</resource>
+			</transformer>
+			<transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
+				<resource>META-INF/spring.schemas</resource>
+			</transformer>
+		</transformers>
+	</configuration>
+</plugin>
+----
+
+== Upload
+
+Build the sample under `spring-cloud-function-samples/function-sample-aws` and upload the `-aws` jar file to Lambda. The handler can be `example.Handler` or `org.springframework.cloud.function.adapter.aws.SpringBootStreamHandler` (FQN of the class, _not_ a method reference, although Lambda does accept method references).
+
+----
+./mvnw -U clean package
+----
+
+Using the AWS command line tools it looks like this:
+
+----
+aws lambda create-function --function-name Uppercase --role arn:aws:iam::[USERID]:role/service-role/[ROLE] --zip-file fileb://function-sample-aws/target/function-sample-aws-2.0.0.BUILD-SNAPSHOT-aws.jar --handler org.springframework.cloud.function.adapter.aws.SpringBootStreamHandler --description "Spring Cloud Function Adapter Example" --runtime java8 --region us-east-1 --timeout 30 --memory-size 1024 --publish
+----
+
+The input type for the function in the AWS sample is a Foo with a single property called "value". So you would need this to test it:
+
+----
+{
+  "value": "test"
+}
+----
+
+NOTE: The AWS sample app is written in the "functional" style (as an `ApplicationContextInitializer`). This is much faster on startup in Lambda than the traditional `@Bean` style, so if you don't need `@Beans` (or `@EnableAutoConfiguration`) it's a good choice. Warm starts are not affected.
+
+
+== Type Conversion
+
+Spring Cloud Function will attempt to transparently handle type conversion between the raw
+input stream and types declared by your function.
+
+For example, if your function signature is as such `Function<Foo, Bar>` we will attempt to convert
+incoming stream event to an instance of `Foo`.
+
+In the event type is not known or can not be determined (e.g., `Function<?, ?>`) we will attempt to
+convert an incoming stream event to a generic `Map`.
+
+==== Raw Input
+
+There are times when you may want to have access to a raw input. In this case all you need is to declare your
+function signature to accept `InputStream`. For example, `Function<InputStream, ?>`. In this case
+we will not attempt any conversion and will pass the raw input directly to a function.
+
+
+
+