diff --git a/README.md b/README.md
index 8961b0b..c2a78db 100644
--- a/README.md
+++ b/README.md
@@ -23,7 +23,7 @@
 <img src="/assets/deploy-demo.gif" height="250" align="right">
 
 1. [**Install**](#1-install)
-2. [**Create**](#2-create)
+2. [**Initialize**](#2-initialize)
 3. [**Deploy**](#3-deploy)
 4. [**Configure**](#4-configure)
 5. [**Develop**](#5-develop)
@@ -40,30 +40,15 @@ To get started with component, install the latest version of the Serverless Fram
 $ npm install -g serverless
 ```
 
-### 2. Create
+After installation, make sure you connect your AWS account by setting a provider in the org setting page on the [Serverless Dashboard](https://app.serverless.com).
 
-You can easily create a new `aws-lambda` instance just by using the following command and template url.
+### 2. Initialize
 
-```
-$ serverless create --template-url https://github.com/serverless/components/tree/master/templates/aws-lambda
-$ cd aws-lambda
-```
-
-Then, create a new `.env` file in the root of the `aws-lambda` directory right next to `serverless.yml`, and add your AWS access keys:
-
-```
-# .env
-AWS_ACCESS_KEY_ID=XXX
-AWS_SECRET_ACCESS_KEY=XXX
-```
-
-You should now have a directory that looks something like this:
+The easiest way to start using the `aws-lambda` component is by initializing the `aws-lambda-starter` template. Just run this command:
 
 ```
-|- src
-  |- index.js
-|- serverless.yml
-|- .env
+$ serverless init aws-lambda-starter
+$ cd aws-lambda-starter
 ```
 
 ### 3. Deploy
@@ -90,18 +75,20 @@ Here's a complete reference of the `serverless.yml` file for the `aws-lambda` co
 component: aws-lambda            # (required) name of the component. In that case, it's aws-lambda.
 name: my-lambda                  # (required) name of your component instance.
 org: serverlessinc               # (optional) serverless dashboard org. default is the first org you created during signup.
-app: myApp                       # (optional) serverless dashboard app. default is the same as the name property.
+app: my-app                      # (optional) serverless dashboard app. default is the same as the name property.
 stage: dev                       # (optional) serverless dashboard stage. default is dev.
 
 inputs:
-  src: ./src                     # (optional) path to the source folder. default is a hello world function.
-  handler: index.handler         # (optional) lambda handler. default is handler.handler.
+  src: ./src                     # (optional) path to the source folder, relative to the cwd. default is a hello world function.
+  name: my-lambda                # (optional) the name of lambda function. default is an auto-generated name based on the instance name and stage above.
+  handler: index.handler         # (optional) lambda handler relative to the src input above. default is handler.handler.
   memory: 512                    # (optional) lambda memory size.
   timeout: 10                    # (optional) lambda timeout.
   description: My Lambda.        # (optional) lambda description.
   env:                           # (optional) env vars.
     FOO: BAR
-  roleArn: arn:aws:abc           # (optional) custom role arn.
+  roleName: plain-name           # (optional) custom role name.
+  retry: 2                       # (optional) async retry configuration. default is 0.
   layers:                        # (optional) lambda layers to add to this lambda function. default is an empty array.
     - aws:layer:arn:1
     - aws:layer:arn:2
@@ -115,11 +102,13 @@ inputs:
   region: us-east-2              # (optional) aws region to deploy to. default is us-east-1.
 ```
 
+**Note:** Unlike the `src` input, the `handler` input is relative to the `src` input, not to the current working directory.
+
 Once you've chosen your configuration, run `serverless deploy` again (or simply just `serverless`) to deploy your changes.
 
 ### 5. Develop
 
-Now that you've got your basic lambda function up and running, it's time to develop that into a function that you could actual use. Instead of having to run `serverless deploy` everytime you make changes you wanna test, you could enable dev mode, which allows the CLI to watch for changes in your source directory as you develop, and deploy instantly on save.
+Now that you've got your basic lambda function up and running, it's time to develop that into a function that you could actual use. Instead of having to run `serverless deploy` everytime you make changes you want to test, you could enable dev mode, which allows the CLI to watch for changes in your source directory as you develop, and deploy instantly on save.
 
 To enable dev mode, just run the following command:
 
@@ -144,7 +133,7 @@ $ serverless info --debug
 ```
 ### 7. Remove
 
-If you wanna tear down your entire `aws-lambda` infrastructure that was created during deployment, just run the following command in the directory containing the `serverless.yml` file. 
+If you want to tear down your entire `aws-lambda` infrastructure that was created during deployment, just run the following command in the directory containing the `serverless.yml` file. 
 ```
 $ serverless remove
 ```
diff --git a/serverless.component.yml b/serverless.component.yml
index 4e7ae4f..c0fcd6d 100644
--- a/serverless.component.yml
+++ b/serverless.component.yml
@@ -1,5 +1,5 @@
 name: aws-lambda
-version: 1.0.2
+version: 3.0.1
 author: eahefnawy
 org: serverlessinc
 description: Deploys an AWS Lambda Function
@@ -7,4 +7,7 @@ keywords: aws, serverless, lambda, function, faas
 repo: https://github.com/serverless-components/aws-lambda
 readme: ''
 license: MIT
-main: ./src
+src: ./src
+types:
+  providers:
+    - aws
diff --git a/src/package.json b/src/package.json
index 84180b4..9bd2bdc 100644
--- a/src/package.json
+++ b/src/package.json
@@ -12,6 +12,7 @@
   "author": "Serverless, Inc.",
   "license": "Apache",
   "dependencies": {
+    "@serverless/aws-sdk-extra": "^0.0.2",
     "archiver": "^3.1.1",
     "fs-extra": "^8.1.0",
     "globby": "^11.0.0",
diff --git a/src/serverless.js b/src/serverless.js
index 28a4b56..769f211 100644
--- a/src/serverless.js
+++ b/src/serverless.js
@@ -4,14 +4,15 @@ const { Component } = require('@serverless/core')
 const {
   prepareInputs,
   getClients,
-  createRole,
-  getRole,
-  removeRole,
   createLambdaFunction,
   updateLambdaFunctionCode,
   updateLambdaFunctionConfig,
   getLambdaFunction,
-  deleteLambdaFunction
+  createOrUpdateFunctionRole,
+  createOrUpdateMetaRole,
+  deleteLambdaFunction,
+  removeAllRoles,
+  getMetrics
 } = require('./utils')
 
 class AwsLambda extends Component {
@@ -20,12 +21,6 @@ class AwsLambda extends Component {
    * @param {*} inputs
    */
   async deploy(inputs = {}) {
-    // this error message assumes that the user is running via the CLI though...
-    if (Object.keys(this.credentials.aws).length === 0) {
-      const msg = `Credentials not found. Make sure you have a .env file in the cwd. - Docs: https://git.io/JvArp`
-      throw new Error(msg)
-    }
-
     // Check size of source code is less than 100MB
     if (this.size > 100000000) {
       throw new Error(
@@ -41,7 +36,7 @@ class AwsLambda extends Component {
     )
 
     // Get AWS clients
-    const { lambda, iam } = getClients(this.credentials.aws, inputs.region)
+    const clients = getClients(this.credentials.aws, inputs.region)
 
     // Throw error on name change
     if (this.state.name && this.state.name !== inputs.name) {
@@ -56,31 +51,15 @@ class AwsLambda extends Component {
       )
     }
 
-    // If no AWS IAM Role role exists, auto-create a default role
-    if (!inputs.roleArn) {
-      console.log(
-        `No AWS IAM Role provided. Creating/Updating default IAM Role with basic execution rights.`
-      )
-      const iamRoleName = `${inputs.name}-role`
-      let res = await getRole(iam, iamRoleName)
-      if (res) {
-        inputs.autoRoleArn = this.state.autoRoleArn = res.Role.Arn
-      } else {
-        res = await createRole(iam, iamRoleName)
-      }
-      inputs.autoRoleArn = this.state.autoRoleArn = res.Role.Arn
-    }
-
-    // If user has put in a custom AWS IAM Role and an auto-created role exists, delete the auto-created role
-    if (inputs.roleArn && this.state.autoRoleArn) {
-      console.log('Detected a new roleArn has been provided.  Removing the auto-created role...')
-      await removeRole(iam, this.state.autoRoleArn)
-    }
+    await Promise.all([
+      createOrUpdateFunctionRole(this, inputs, clients),
+      createOrUpdateMetaRole(this, inputs, clients, this.accountId)
+    ])
 
     console.log(
       `Checking if an AWS Lambda function has already been created with name: ${inputs.name}`
     )
-    const prevLambda = await getLambdaFunction(lambda, inputs.name)
+    const prevLambda = await getLambdaFunction(clients.lambda, inputs.name)
 
     const filesPath = await this.unzip(inputs.src, true) // Returns directory with unzipped files
 
@@ -98,16 +77,16 @@ class AwsLambda extends Component {
       console.log(
         `Creating a new AWS Lambda function "${inputs.name}" in the "${inputs.region}" region.`
       )
-      const createResult = await createLambdaFunction(lambda, inputs)
+      const createResult = await createLambdaFunction(this, clients.lambda, inputs)
       inputs.arn = createResult.arn
       inputs.hash = createResult.hash
       console.log(`Successfully created an AWS Lambda function`)
     } else {
       // Update a Lambda function
       inputs.arn = prevLambda.arn
-      console.log(`Updatinng ${inputs.name} AWS lambda function.`)
-      await updateLambdaFunctionCode(lambda, inputs)
-      await updateLambdaFunctionConfig(lambda, inputs)
+      console.log(`Updating ${inputs.name} AWS lambda function.`)
+      await updateLambdaFunctionCode(clients.lambda, inputs)
+      await updateLambdaFunctionConfig(this, clients.lambda, inputs)
       console.log(`Successfully updated AWS Lambda function`)
     }
 
@@ -129,28 +108,50 @@ class AwsLambda extends Component {
    * @param {*} inputs
    */
   async remove(inputs = {}) {
+    // this error message assumes that the user is running via the CLI though...
+    if (Object.keys(this.credentials.aws).length === 0) {
+      const msg = `Credentials not found. Make sure you have a .env file in the cwd. - Docs: https://git.io/JvArp`
+      throw new Error(msg)
+    }
+
     if (!this.state.name) {
       console.log(`No state found.  Function appears removed already.  Aborting.`)
       return
     }
 
-    const { name, region } = this.state
-    const { iam, lambda } = getClients(this.credentials.aws, region)
+    const clients = getClients(this.credentials.aws, this.state.region)
 
-    if (this.state.autoRoleArn) {
-      console.log(
-        `Removing role that was automatically created for this function with ARN: ${this.state.autoRoleArn}.`
-      )
-      await removeRole(iam, this.state.autoRoleArn)
-      this.state.autoRoleArn = undefined
-    }
+    await removeAllRoles(this, clients)
+
+    console.log(`Removing lambda ${this.state.name} from the ${this.state.region} region.`)
+    await deleteLambdaFunction(clients.lambda, this.state.name)
+    console.log(
+      `Successfully removed lambda ${this.state.name} from the ${this.state.region} region.`
+    )
 
-    console.log(`Removing lambda ${name} from the ${region} region.`)
-    await deleteLambdaFunction(lambda, name)
-    console.log(`Successfully removed lambda ${name} from the ${region} region.`)
     this.state = {}
     return {}
   }
+
+  /**
+   * Metrics
+   */
+  async metrics(inputs = {}) {
+    // Validate
+    if (!inputs.rangeStart || !inputs.rangeEnd) {
+      throw new Error('rangeStart and rangeEnd are require inputs')
+    }
+
+    const result = await getMetrics(
+      this.state.region,
+      this.state.metaRoleArn,
+      this.state.name,
+      inputs.rangeStart,
+      inputs.rangeEnd
+    )
+
+    return result
+  }
 }
 
 /**
diff --git a/src/utils.js b/src/utils.js
index 73dec3d..5f1e5df 100644
--- a/src/utils.js
+++ b/src/utils.js
@@ -1,23 +1,18 @@
-const AWS = require('aws-sdk')
+const https = require('https')
+const AWS = require('@serverless/aws-sdk-extra')
 const { equals, not, pick } = require('ramda')
 const { readFile } = require('fs-extra')
 
+const agent = new https.Agent({
+  keepAlive: true
+})
+
 /**
  * Sleep
  * @param {*} wait
  */
 const sleep = async (wait) => new Promise((resolve) => setTimeout(() => resolve(), wait))
 
-/**
- * Get AWS Account ID
- * @param {*} aws
- */
-const getAccountId = async (aws) => {
-  const STS = new aws.STS()
-  const res = await STS.getCallerIdentity({}).promise()
-  return res.Account
-}
-
 /**
  * Generate a random ID
  */
@@ -30,16 +25,18 @@ const randomId = Math.random()
  * @param {*} credentials
  * @param {*} region
  */
-const getClients = (credentials, region) => {
-  // this error message assumes that the user is running via the CLI though...
-  if (Object.keys(credentials).length === 0) {
-    const msg = `Credentials not found. Make sure you have a .env file in the cwd. - Docs: https://git.io/JvArp`
-    throw new Error(msg)
-  }
+const getClients = (credentials = {}, region) => {
+  AWS.config.update({
+    httpOptions: {
+      agent
+    }
+  })
 
+  const extras = new AWS.Extras({ credentials, region })
   const iam = new AWS.IAM({ credentials, region })
   const lambda = new AWS.Lambda({ credentials, region })
-  return { iam, lambda }
+  const sts = new AWS.STS({ credentials, region })
+  return { iam, lambda, extras, sts }
 }
 
 /**
@@ -49,11 +46,11 @@ const getClients = (credentials, region) => {
  */
 const prepareInputs = (inputs, instance) => {
   return {
-    name:
-      inputs.name || instance.state.name || `aws-lambda-component-${instance.stage}-${randomId}`,
-    roleArn: inputs.roleArn || instance.state.roleArn,
-    roleName: `lambda-role-${instance.stage}-${randomId}`,
-    description: inputs.description || 'AWS Lambda Component',
+    name: inputs.name || instance.state.name || `${instance.name}-${instance.stage}-${randomId}`,
+    roleName: inputs.roleName,
+    description:
+      inputs.description ||
+      `An AWS Lambda function from the AWS Lambda Serverless Framework Component.  Name: "${instance.name}" Stage: "${instance.stage}"`,
     memory: inputs.memory || 1028,
     timeout: inputs.timeout || 10,
     src: inputs.src || null,
@@ -63,89 +60,137 @@ const prepareInputs = (inputs, instance) => {
     region: inputs.region || 'us-east-1',
     layers: inputs.layers || [],
     securityGroupIds: inputs.vpcConfig ? inputs.vpcConfig.securityGroupIds : false,
-    subnetIds: inputs.vpcConfig ? inputs.vpcConfig.subnetIds : false
+    subnetIds: inputs.vpcConfig ? inputs.vpcConfig.subnetIds : false,
+    retry: inputs.retry || 0
   }
 }
 
-/**
- * Create an AWS IAM Role
- * @param {*} iam
- * @param {*} config
+/*
+ * Ensure the provided IAM Role or default IAM Role exists
+ *
+ * @param ${instance} instance - the component instance
+ * @param ${object} inputs - the component inputs
+ * @param ${object} clients - the aws clients object
  */
-const createRole = async (iam, roleName) => {
-  const assumeRolePolicyDocument = {
-    Version: '2012-10-17',
-    Statement: {
-      Effect: 'Allow',
-      Principal: {
-        Service: ['lambda.amazonaws.com']
-      },
-      Action: 'sts:AssumeRole'
+const createOrUpdateFunctionRole = async (instance, inputs, clients) => {
+  // Verify existing role, either provided or the previously created default role...
+  if (inputs.roleName) {
+    console.log(
+      `Verifying the provided IAM Role with the name: ${inputs.roleName} in the inputs exists...`
+    )
+
+    const userRole = await clients.extras.getRole({ roleName: inputs.roleName })
+    const userRoleArn = userRole && userRole.Role && userRole.Role.Arn ? userRole.Role.Arn : null // Don't save user provided role to state, always reference it as an input, in case it changes
+
+    // If user role exists, save it to state so it can be used for the create/update lambda logic later
+    if (userRoleArn) {
+      console.log(`The provided IAM Role with the name: ${inputs.roleName} in the inputs exists.`)
+      instance.state.userRoleArn = userRoleArn
+
+      // Save AWS Account ID by fetching the role ID
+      // TODO: This may not work with cross-account roles.
+      instance.state.awsAccountId = instance.state.userRoleArn.split(':')[4]
+
+      // Be sure to delete defaultLambdaRoleArn data, if it exists
+      if (instance.state.defaultLambdaRoleArn) {
+        delete instance.state.defaultLambdaRoleArn
+      }
+    } else {
+      throw new Error(`The provided IAM Role with the name: ${inputs.roleName} could not be found.`)
     }
-  }
+  } else {
+    // Create a default role with basic Lambda permissions
 
-  const res = await iam
-    .createRole({
-      RoleName: roleName,
-      Path: '/',
-      AssumeRolePolicyDocument: JSON.stringify(assumeRolePolicyDocument)
-    })
-    .promise()
+    const defaultLambdaRoleName = `${inputs.name}-lambda-role`
+    console.log(
+      `IAM Role not found.  Creating or updating a default role with the name: ${defaultLambdaRoleName}`
+    )
 
-  await iam
-    .attachRolePolicy({
-      RoleName: roleName,
-      PolicyArn: 'arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole'
+    const result = await clients.extras.deployRole({
+      roleName: defaultLambdaRoleName,
+      service: ['lambda.amazonaws.com'],
+      policy: 'arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole'
     })
-    .promise()
 
-  return res
-}
+    instance.state.defaultLambdaRoleName = defaultLambdaRoleName
+    instance.state.defaultLambdaRoleArn = result.roleArn
+    instance.state.awsAccountId = instance.state.defaultLambdaRoleArn.split(':')[4]
 
-/**
- * Get an AWS IAM Role
- * @param {*} iam
- * @param {*} config
- */
-const getRole = async (iam, roleName) => {
-  let res
-  try {
-    res = await iam
-      .getRole({
-        RoleName: roleName
-      })
-      .promise()
-  } catch (error) {
-    if (error.code && error.code === 'NoSuchEntity') {
-      return
+    // Be sure to delete userRole data, if it exists
+    if (instance.state.userRoleArn) {
+      delete instance.state.userRoleArn
     }
-    throw error
+
+    console.log(
+      `Default Lambda IAM Role created or updated with ARN ${instance.state.defaultLambdaRoleArn}`
+    )
   }
-  return res
 }
 
-/**
- * Remove AWS IAM Role
- * @param {*} iam
- * @param {*} config
+/*
+ * Ensure the Meta IAM Role exists
  */
-const removeRole = async (iam, autoRoleArn) => {
-  try {
-    await iam
-      .detachRolePolicy({
-        RoleName: autoRoleArn.split('/')[1], // extract role name from arn
-        PolicyArn: 'arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole'
-      })
-      .promise()
-    await iam
-      .deleteRole({
-        RoleName: autoRoleArn.split('/')[1]
-      })
-      .promise()
-  } catch (error) {
-    if (error.code !== 'NoSuchEntity') {
-      throw error
+const createOrUpdateMetaRole = async (instance, inputs, clients, serverlessAccountId) => {
+  // Create or update Meta Role for monitoring and more, if option is enabled.  It's enabled by default.
+  if (inputs.monitoring || typeof inputs.monitoring === 'undefined') {
+    console.log('Creating or updating the meta IAM Role...')
+
+    const roleName = `${instance.name}-meta-role`
+
+    const assumeRolePolicyDocument = {
+      Version: '2012-10-17',
+      Statement: {
+        Effect: 'Allow',
+        Principal: {
+          AWS: `arn:aws:iam::${serverlessAccountId}:root` // Serverless's Components account
+        },
+        Action: 'sts:AssumeRole'
+      }
     }
+
+    // Create a policy that only can access APIGateway and Lambda metrics, logs from CloudWatch...
+    const policy = {
+      Version: '2012-10-17',
+      Statement: [
+        {
+          Effect: 'Allow',
+          Resource: '*',
+          Action: [
+            'cloudwatch:Describe*',
+            'cloudwatch:Get*',
+            'cloudwatch:List*',
+            'logs:Get*',
+            'logs:List*',
+            'logs:Describe*',
+            'logs:TestMetricFilter',
+            'logs:FilterLogEvents'
+          ]
+          // TODO: Finish this.  Haven't been able to get this to work.  Perhaps there is a missing service (Cloudfront?)
+          // Condition: {
+          //   StringEquals: {
+          //     'cloudwatch:namespace': [
+          //       'AWS/ApiGateway',
+          //       'AWS/Lambda'
+          //     ]
+          //   }
+          // }
+        }
+      ]
+    }
+
+    const roleDescription = `The Meta Role for the Serverless Framework App: ${instance.name} Stage: ${instance.stage}`
+
+    const result = await clients.extras.deployRole({
+      roleName,
+      roleDescription,
+      policy,
+      assumeRolePolicyDocument
+    })
+
+    instance.state.metaRoleName = roleName
+    instance.state.metaRoleArn = result.roleArn
+
+    console.log(`Meta IAM Role created or updated with ARN ${instance.state.metaRoleArn}`)
   }
 }
 
@@ -154,7 +199,7 @@ const removeRole = async (iam, autoRoleArn) => {
  * @param {*} lambda
  * @param {*} config
  */
-const createLambdaFunction = async (lambda, inputs) => {
+const createLambdaFunction = async (instance, lambda, inputs) => {
   const params = {
     FunctionName: inputs.name,
     Code: {},
@@ -162,7 +207,7 @@ const createLambdaFunction = async (lambda, inputs) => {
     Handler: inputs.handler,
     MemorySize: inputs.memory,
     Publish: true,
-    Role: inputs.roleArn || inputs.autoRoleArn,
+    Role: instance.state.userRoleArn || instance.state.defaultLambdaRoleArn,
     Runtime: inputs.runtime,
     Timeout: inputs.timeout,
     Layers: inputs.layers,
@@ -186,7 +231,7 @@ const createLambdaFunction = async (lambda, inputs) => {
     if (e.message.includes(`The role defined for the function cannot be assumed by Lambda`)) {
       // we need to wait after the role is created before it can be assumed
       await sleep(5000)
-      return await createLambdaFunction(lambda, inputs)
+      return await createLambdaFunction(instance, lambda, inputs)
     }
     throw e
   }
@@ -197,13 +242,13 @@ const createLambdaFunction = async (lambda, inputs) => {
  * @param {*} lambda
  * @param {*} config
  */
-const updateLambdaFunctionConfig = async (lambda, inputs) => {
+const updateLambdaFunctionConfig = async (instance, lambda, inputs) => {
   const functionConfigParams = {
     FunctionName: inputs.name,
     Description: inputs.description,
     Handler: inputs.handler,
     MemorySize: inputs.memory,
-    Role: inputs.roleArn || inputs.autoRoleArn,
+    Role: instance.state.userRoleArn || instance.state.defaultLambdaRoleArn,
     Runtime: inputs.runtime,
     Timeout: inputs.timeout,
     Layers: inputs.layers,
@@ -225,7 +270,25 @@ const updateLambdaFunctionConfig = async (lambda, inputs) => {
         })
   }
 
-  const res = await lambda.updateFunctionConfiguration(functionConfigParams).promise()
+  let res
+  try {
+    res = await lambda.updateFunctionConfiguration(functionConfigParams).promise()
+  } catch (e) {
+    if (e.code === 'ResourceConflictException') {
+      await sleep(2000)
+      return await updateLambdaFunctionConfig(instance, lambda, inputs)
+    }
+    throw e
+  }
+
+  // update retry config
+  await lambda
+    .putFunctionEventInvokeConfig({
+      FunctionName: inputs.name,
+      MaximumRetryAttempts: inputs.retry
+    })
+    .promise()
+
   return { arn: res.FunctionArn, hash: res.CodeSha256 }
 }
 
@@ -344,21 +407,92 @@ const inputsChanged = (prevLambda, lambda) => {
   return not(equals(inputs, prevInputs))
 }
 
+/*
+ * Removes the Function & Meta Roles from aws according to the provided config
+ *
+ * @param ${object} clients - an object containing aws sdk clients
+ * @param ${object} config - the component config
+ */
+const removeAllRoles = async (instance, clients) => {
+  // Delete Function Role
+  if (instance.state.defaultLambdaRoleName) {
+    console.log('Deleting the default Function Role...')
+    await clients.extras.removeRole({
+      roleName: instance.state.defaultLambdaRoleName
+    })
+  }
+
+  // Delete Meta Role
+  if (instance.state.metaRoleName) {
+    console.log('Deleting the Meta Role...')
+    await clients.extras.removeRole({
+      roleName: instance.state.metaRoleName
+    })
+  }
+}
+
+/**
+ * Get metrics from cloudwatch
+ * @param {*} clients
+ * @param {*} rangeStart MUST be a moment() object
+ * @param {*} rangeEnd MUST be a moment() object
+ */
+const getMetrics = async (region, metaRoleArn, functionName, rangeStart, rangeEnd) => {
+  /**
+   * Create AWS STS Token via the meta role that is deployed with the Express Component
+   */
+
+  // Assume Role
+  const assumeParams = {}
+  assumeParams.RoleSessionName = `session${Date.now()}`
+  assumeParams.RoleArn = metaRoleArn
+  assumeParams.DurationSeconds = 900
+
+  const sts = new AWS.STS({ region })
+  const resAssume = await sts.assumeRole(assumeParams).promise()
+
+  const roleCreds = {}
+  roleCreds.accessKeyId = resAssume.Credentials.AccessKeyId
+  roleCreds.secretAccessKey = resAssume.Credentials.SecretAccessKey
+  roleCreds.sessionToken = resAssume.Credentials.SessionToken
+
+  /**
+   * Instantiate a new Extras instance w/ the temporary credentials
+   */
+
+  const extras = new AWS.Extras({
+    credentials: roleCreds,
+    region
+  })
+
+  const resources = [
+    {
+      type: 'aws_lambda',
+      functionName
+    }
+  ]
+
+  return await extras.getMetrics({
+    rangeStart,
+    rangeEnd,
+    resources
+  })
+}
+
 /**
  * Exports
  */
 module.exports = {
   prepareInputs,
   getClients,
-  createRole,
-  getRole,
-  removeRole,
+  createOrUpdateFunctionRole,
+  createOrUpdateMetaRole,
   createLambdaFunction,
   updateLambdaFunctionCode,
   updateLambdaFunctionConfig,
   getLambdaFunction,
+  inputsChanged,
   deleteLambdaFunction,
-  getPolicy,
-  getAccountId,
-  inputsChanged
+  removeAllRoles,
+  getMetrics
 }
diff --git a/templates/aws-lambda-starter/serverless.template.yml b/templates/aws-lambda-starter/serverless.template.yml
new file mode 100644
index 0000000..26fd55f
--- /dev/null
+++ b/templates/aws-lambda-starter/serverless.template.yml
@@ -0,0 +1,6 @@
+name: aws-lambda-starter
+org: serverlessinc
+description: Deploys an AWS Lambda function
+keywords: aws, serverless, faas, lambda
+repo: https://github.com/serverless-components/aws-lambda
+license: MIT
\ No newline at end of file
diff --git a/templates/aws-lambda-starter/serverless.yml b/templates/aws-lambda-starter/serverless.yml
index 84adee8..68aad14 100644
--- a/templates/aws-lambda-starter/serverless.yml
+++ b/templates/aws-lambda-starter/serverless.yml
@@ -1,10 +1,6 @@
 name: aws-lambda-starter
 component: aws-lambda
 org: serverlessinc
-description: Deploys an AWS Lambda function
-keywords: aws, serverless, faas, lambda
-repo: https://github.com/serverless-components/aws-lambda
-license: MIT
 
 inputs:
   src: ./src
diff --git a/templates/aws-lambda-starter/src/handler.js b/templates/aws-lambda-starter/src/handler.js
index bc2ab3f..3504d74 100644
--- a/templates/aws-lambda-starter/src/handler.js
+++ b/templates/aws-lambda-starter/src/handler.js
@@ -1,6 +1,4 @@
-'use strict';
-
 module.exports.handler = async (event, context) => {
-  console.log('hello world');
-  return 'successful invocation';
-};
+  console.log('hello world')
+  return 'successful invocation'
+}
