diff --git a/aws/provider.go b/aws/provider.go
index 219efe2fe33..6ef07b28141 100644
--- a/aws/provider.go
+++ b/aws/provider.go
@@ -261,6 +261,7 @@ func Provider() terraform.ResourceProvider {
 			"aws_app_cookie_stickiness_policy":             resourceAwsAppCookieStickinessPolicy(),
 			"aws_appautoscaling_target":                    resourceAwsAppautoscalingTarget(),
 			"aws_appautoscaling_policy":                    resourceAwsAppautoscalingPolicy(),
+			"aws_appautoscaling_scheduled_action":          resourceAwsAppautoscalingScheduledAction(),
 			"aws_athena_database":                          resourceAwsAthenaDatabase(),
 			"aws_athena_named_query":                       resourceAwsAthenaNamedQuery(),
 			"aws_autoscaling_attachment":                   resourceAwsAutoscalingAttachment(),
diff --git a/aws/resource_aws_appautoscaling_scheduled_action.go b/aws/resource_aws_appautoscaling_scheduled_action.go
new file mode 100644
index 00000000000..0cccbeb4eba
--- /dev/null
+++ b/aws/resource_aws_appautoscaling_scheduled_action.go
@@ -0,0 +1,191 @@
+package aws
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/applicationautoscaling"
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/helper/schema"
+)
+
+const awsAppautoscalingScheduleTimeLayout = "2006-01-02T15:04:05Z"
+
+func resourceAwsAppautoscalingScheduledAction() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceAwsAppautoscalingScheduledActionPut,
+		Read:   resourceAwsAppautoscalingScheduledActionRead,
+		Delete: resourceAwsAppautoscalingScheduledActionDelete,
+
+		Schema: map[string]*schema.Schema{
+			"name": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"service_namespace": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"resource_id": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"scalable_dimension": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+			"scalable_target_action": &schema.Schema{
+				Type:     schema.TypeList,
+				Optional: true,
+				ForceNew: true,
+				MaxItems: 1,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"max_capacity": &schema.Schema{
+							Type:     schema.TypeInt,
+							Optional: true,
+							ForceNew: true,
+						},
+						"min_capacity": &schema.Schema{
+							Type:     schema.TypeInt,
+							Optional: true,
+							ForceNew: true,
+						},
+					},
+				},
+			},
+			"schedule": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+			"start_time": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+			"end_time": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+			"arn": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+		},
+	}
+}
+
+func resourceAwsAppautoscalingScheduledActionPut(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).appautoscalingconn
+
+	input := &applicationautoscaling.PutScheduledActionInput{
+		ScheduledActionName: aws.String(d.Get("name").(string)),
+		ServiceNamespace:    aws.String(d.Get("service_namespace").(string)),
+		ResourceId:          aws.String(d.Get("resource_id").(string)),
+	}
+	if v, ok := d.GetOk("scalable_dimension"); ok {
+		input.ScalableDimension = aws.String(v.(string))
+	}
+	if v, ok := d.GetOk("schedule"); ok {
+		input.Schedule = aws.String(v.(string))
+	}
+	if v, ok := d.GetOk("scalable_target_action"); ok {
+		sta := &applicationautoscaling.ScalableTargetAction{}
+		raw := v.([]interface{})[0].(map[string]interface{})
+		if max, ok := raw["max_capacity"]; ok {
+			sta.MaxCapacity = aws.Int64(int64(max.(int)))
+		}
+		if min, ok := raw["min_capacity"]; ok {
+			sta.MaxCapacity = aws.Int64(int64(min.(int)))
+		}
+		input.ScalableTargetAction = sta
+	}
+	if v, ok := d.GetOk("start_time"); ok {
+		t, err := time.Parse(awsAppautoscalingScheduleTimeLayout, v.(string))
+		if err != nil {
+			return fmt.Errorf("Error Parsing Appautoscaling Scheduled Action Start Time: %s", err.Error())
+		}
+		input.StartTime = aws.Time(t)
+	}
+	if v, ok := d.GetOk("end_time"); ok {
+		t, err := time.Parse(awsAppautoscalingScheduleTimeLayout, v.(string))
+		if err != nil {
+			return fmt.Errorf("Error Parsing Appautoscaling Scheduled Action End Time: %s", err.Error())
+		}
+		input.EndTime = aws.Time(t)
+	}
+
+	err := resource.Retry(5*time.Minute, func() *resource.RetryError {
+		_, err := conn.PutScheduledAction(input)
+		if err != nil {
+			if isAWSErr(err, applicationautoscaling.ErrCodeObjectNotFoundException, "") {
+				return resource.RetryableError(err)
+			}
+			return resource.NonRetryableError(err)
+		}
+		return nil
+	})
+
+	if err != nil {
+		return err
+	}
+
+	d.SetId(d.Get("name").(string) + "-" + d.Get("service_namespace").(string) + "-" + d.Get("resource_id").(string))
+	return resourceAwsAppautoscalingScheduledActionRead(d, meta)
+}
+
+func resourceAwsAppautoscalingScheduledActionRead(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).appautoscalingconn
+
+	saName := d.Get("name").(string)
+	input := &applicationautoscaling.DescribeScheduledActionsInput{
+		ScheduledActionNames: []*string{aws.String(saName)},
+		ServiceNamespace:     aws.String(d.Get("service_namespace").(string)),
+	}
+	resp, err := conn.DescribeScheduledActions(input)
+	if err != nil {
+		return err
+	}
+	if len(resp.ScheduledActions) < 1 {
+		d.SetId("")
+		return nil
+	}
+	if len(resp.ScheduledActions) != 1 {
+		return fmt.Errorf("Expected 1 scheduled action under %s, found %d", saName, len(resp.ScheduledActions))
+	}
+	if *resp.ScheduledActions[0].ScheduledActionName != saName {
+		return fmt.Errorf("Scheduled Action (%s) not found", saName)
+	}
+	d.Set("arn", resp.ScheduledActions[0].ScheduledActionARN)
+	return nil
+}
+
+func resourceAwsAppautoscalingScheduledActionDelete(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).appautoscalingconn
+
+	input := &applicationautoscaling.DeleteScheduledActionInput{
+		ScheduledActionName: aws.String(d.Get("name").(string)),
+		ServiceNamespace:    aws.String(d.Get("service_namespace").(string)),
+		ResourceId:          aws.String(d.Get("resource_id").(string)),
+	}
+	if v, ok := d.GetOk("scalable_dimension"); ok {
+		input.ScalableDimension = aws.String(v.(string))
+	}
+	_, err := conn.DeleteScheduledAction(input)
+	if err != nil {
+		if isAWSErr(err, applicationautoscaling.ErrCodeObjectNotFoundException, "") {
+			d.SetId("")
+			return nil
+		}
+		return err
+	}
+	d.SetId("")
+	return nil
+}
diff --git a/aws/resource_aws_appautoscaling_scheduled_action_test.go b/aws/resource_aws_appautoscaling_scheduled_action_test.go
new file mode 100644
index 00000000000..bff9dfea906
--- /dev/null
+++ b/aws/resource_aws_appautoscaling_scheduled_action_test.go
@@ -0,0 +1,679 @@
+package aws
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/applicationautoscaling"
+	"github.com/hashicorp/terraform/helper/acctest"
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/terraform"
+)
+
+func TestAccAwsAppautoscalingScheduledAction_dynamo(t *testing.T) {
+	ts := time.Now().AddDate(0, 0, 1).Format("2006-01-02T15:04:05")
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckAwsAppautoscalingScheduledActionDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccAppautoscalingScheduledActionConfig_DynamoDB(acctest.RandString(5), ts),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckAwsAppautoscalingScheduledActionExists("aws_appautoscaling_scheduled_action.hoge"),
+				),
+			},
+		},
+	})
+}
+
+func TestAccAwsAppautoscalingScheduledAction_ECS(t *testing.T) {
+	ts := time.Now().AddDate(0, 0, 1).Format("2006-01-02T15:04:05")
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckAwsAppautoscalingScheduledActionDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccAppautoscalingScheduledActionConfig_ECS(acctest.RandString(5), ts),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckAwsAppautoscalingScheduledActionExists("aws_appautoscaling_scheduled_action.hoge"),
+				),
+			},
+		},
+	})
+}
+
+func TestAccAwsAppautoscalingScheduledAction_EMR(t *testing.T) {
+	ts := time.Now().AddDate(0, 0, 1).Format("2006-01-02T15:04:05")
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckAwsAppautoscalingScheduledActionDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccAppautoscalingScheduledActionConfig_EMR(acctest.RandString(5), ts),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckAwsAppautoscalingScheduledActionExists("aws_appautoscaling_scheduled_action.hoge"),
+				),
+			},
+		},
+	})
+}
+
+func TestAccAwsAppautoscalingScheduledAction_SpotFleet(t *testing.T) {
+	ts := time.Now().AddDate(0, 0, 1).Format("2006-01-02T15:04:05")
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckAwsAppautoscalingScheduledActionDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccAppautoscalingScheduledActionConfig_SpotFleet(acctest.RandString(5), ts),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckAwsAppautoscalingScheduledActionExists("aws_appautoscaling_scheduled_action.hoge"),
+				),
+			},
+		},
+	})
+}
+
+func testAccCheckAwsAppautoscalingScheduledActionDestroy(s *terraform.State) error {
+	conn := testAccProvider.Meta().(*AWSClient).appautoscalingconn
+
+	for _, rs := range s.RootModule().Resources {
+		if rs.Type != "aws_appautoscaling_scheduled_action" {
+			continue
+		}
+
+		input := &applicationautoscaling.DescribeScheduledActionsInput{
+			ScheduledActionNames: []*string{aws.String(rs.Primary.Attributes["name"])},
+			ServiceNamespace:     aws.String(rs.Primary.Attributes["service_namespace"]),
+		}
+		resp, err := conn.DescribeScheduledActions(input)
+		if err != nil {
+			return err
+		}
+		if len(resp.ScheduledActions) > 0 {
+			return fmt.Errorf("Appautoscaling Scheduled Action (%s) not deleted", rs.Primary.Attributes["name"])
+		}
+	}
+	return nil
+}
+
+func testAccCheckAwsAppautoscalingScheduledActionExists(name string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		_, ok := s.RootModule().Resources[name]
+		if !ok {
+			return fmt.Errorf("Not found: %s", name)
+		}
+		return nil
+	}
+}
+
+func testAccAppautoscalingScheduledActionConfig_DynamoDB(rName, ts string) string {
+	return fmt.Sprintf(`
+resource "aws_dynamodb_table" "hoge" {
+  name = "tf-ddb-%s"
+  read_capacity = 5
+  write_capacity = 5
+  hash_key = "UserID"
+
+  attribute {
+    name = "UserID"
+    type = "S"
+  }
+}
+
+resource "aws_iam_role" "hoge" {
+  assume_role_policy = <<EOF
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Principal": {
+        "Service": "application-autoscaling.amazonaws.com"
+      },
+      "Action": "sts:AssumeRole"
+    }
+  ]
+}
+EOF
+}
+
+resource "aws_iam_role_policy" "hoge" {
+  role = "${aws_iam_role.hoge.name}"
+  policy = <<POLICY
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Action": [
+        "dynamodb:DescribeTable",
+        "dynamodb:UpdateTable",
+        "cloudwatch:PutMetricAlarm",
+        "cloudwatch:DescribeAlarms",
+        "cloudwatch:DeleteAlarms"
+      ],
+      "Resource": "*"
+    }
+  ]
+}
+POLICY
+}
+
+resource "aws_appautoscaling_target" "read" {
+  service_namespace = "dynamodb"
+  resource_id = "table/${aws_dynamodb_table.hoge.name}"
+  scalable_dimension = "dynamodb:table:ReadCapacityUnits"
+  role_arn = "${aws_iam_role.hoge.arn}"
+  min_capacity = 1
+  max_capacity = 10
+  depends_on = ["aws_iam_role_policy.hoge"]
+}
+
+resource "aws_appautoscaling_scheduled_action" "hoge" {
+  name = "tf-appauto-%s"
+  service_namespace = "${aws_appautoscaling_target.read.service_namespace}"
+  resource_id = "${aws_appautoscaling_target.read.resource_id}"
+  scalable_dimension = "${aws_appautoscaling_target.read.scalable_dimension}"
+  schedule = "at(%s)"
+
+  scalable_target_action {
+    min_capacity = 1
+    max_capacity = 10
+  }
+}
+`, rName, rName, ts)
+}
+
+func testAccAppautoscalingScheduledActionConfig_ECS(rName, ts string) string {
+	return fmt.Sprintf(`
+resource "aws_iam_role" "hoge" {
+  assume_role_policy = <<EOF
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Principal": {
+        "Service": "application-autoscaling.amazonaws.com"
+      },
+      "Action": "sts:AssumeRole"
+    }
+  ]
+}
+EOF
+}
+
+resource "aws_iam_role_policy" "hoge" {
+  role = "${aws_iam_role.hoge.id}"
+  policy = <<EOF
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Action": [
+        "ecs:DescribeServices",
+        "ecs:UpdateService",
+        "cloudwatch:DescribeAlarms"
+      ],
+      "Resource": [
+        "*"
+      ]
+    }
+  ]
+}
+EOF
+}
+
+resource "aws_ecs_cluster" "hoge" {
+  name = "tf-ecs-cluster-%s"
+}
+
+resource "aws_ecs_task_definition" "hoge" {
+  family = "foobar%s"
+  container_definitions = <<EOF
+[
+  {
+    "name": "busybox",
+    "image": "busybox:latest",
+    "cpu": 10,
+    "memory": 128,
+    "essential": true
+  }
+]
+EOF
+}
+
+resource "aws_ecs_service" "hoge" {
+  name = "tf-ecs-service-%s"
+  cluster = "${aws_ecs_cluster.hoge.id}"
+  task_definition = "${aws_ecs_task_definition.hoge.arn}"
+  desired_count = 1
+
+  deployment_maximum_percent = 200
+  deployment_minimum_healthy_percent = 50
+}
+
+resource "aws_appautoscaling_target" "hoge" {
+  service_namespace = "ecs"
+  resource_id = "service/${aws_ecs_cluster.hoge.name}/${aws_ecs_service.hoge.name}"
+  scalable_dimension = "ecs:service:DesiredCount"
+  role_arn = "${aws_iam_role.hoge.arn}"
+  min_capacity = 1
+  max_capacity = 3
+}
+
+resource "aws_appautoscaling_scheduled_action" "hoge" {
+  name = "tf-appauto-%s"
+  service_namespace = "${aws_appautoscaling_target.hoge.service_namespace}"
+  resource_id = "${aws_appautoscaling_target.hoge.resource_id}"
+  scalable_dimension = "${aws_appautoscaling_target.hoge.scalable_dimension}"
+  schedule = "at(%s)"
+
+  scalable_target_action {
+    min_capacity = 1
+    max_capacity = 5
+  }
+}
+`, rName, rName, rName, rName, ts)
+}
+
+func testAccAppautoscalingScheduledActionConfig_EMR(rName, ts string) string {
+	return fmt.Sprintf(`
+resource "aws_emr_cluster" "hoge" {
+  name          = "tf-emr-%s"
+  release_label = "emr-5.4.0"
+  applications  = ["Spark"]
+
+  ec2_attributes {
+    subnet_id                         = "${aws_subnet.hoge.id}"
+    emr_managed_master_security_group = "${aws_security_group.hoge.id}"
+    emr_managed_slave_security_group  = "${aws_security_group.hoge.id}"
+    instance_profile                  = "${aws_iam_instance_profile.instance_profile.arn}"
+  }
+
+  master_instance_type = "m4.large"
+  core_instance_type   = "m4.large"
+  core_instance_count  = 2
+
+  tags {
+    role = "rolename"
+    dns_zone = "env_zone"
+    env = "env"
+    name = "name-env"
+  }
+
+  keep_job_flow_alive_when_no_steps = true
+
+  bootstrap_action {
+    path = "s3://elasticmapreduce/bootstrap-actions/run-if"
+    name = "runif"
+    args = ["instance.isMaster=true", "echo running on master node"]
+  }
+
+  configurations = "test-fixtures/emr_configurations.json"
+
+  depends_on = ["aws_main_route_table_association.hoge"]
+
+  service_role = "${aws_iam_role.emr_role.arn}"
+  autoscaling_role = "${aws_iam_role.autoscale_role.arn}"
+}
+
+resource "aws_emr_instance_group" "hoge" {
+  cluster_id     = "${aws_emr_cluster.hoge.id}"
+  instance_count = 1
+  instance_type  = "m4.large"
+}
+
+resource "aws_security_group" "hoge" {
+  name        = "tf-sg-%s"
+  description = "Allow all inbound traffic"
+  vpc_id      = "${aws_vpc.hoge.id}"
+
+  ingress {
+    from_port   = 0
+    to_port     = 0
+    protocol    = "-1"
+    cidr_blocks = ["0.0.0.0/0"]
+  }
+
+  egress {
+    from_port   = 0
+    to_port     = 0
+    protocol    = "-1"
+    cidr_blocks = ["0.0.0.0/0"]
+  }
+
+  depends_on = ["aws_subnet.hoge"]
+
+  lifecycle {
+    ignore_changes = ["ingress", "egress"]
+  }
+}
+
+resource "aws_vpc" "hoge" {
+  cidr_block           = "168.31.0.0/16"
+  enable_dns_hostnames = true
+}
+
+resource "aws_subnet" "hoge" {
+  vpc_id     = "${aws_vpc.hoge.id}"
+  cidr_block = "168.31.0.0/20"
+}
+
+resource "aws_internet_gateway" "hoge" {
+  vpc_id = "${aws_vpc.hoge.id}"
+}
+
+resource "aws_route_table" "hoge" {
+  vpc_id = "${aws_vpc.hoge.id}"
+
+  route {
+    cidr_block = "0.0.0.0/0"
+    gateway_id = "${aws_internet_gateway.hoge.id}"
+  }
+}
+
+resource "aws_main_route_table_association" "hoge" {
+  vpc_id         = "${aws_vpc.hoge.id}"
+  route_table_id = "${aws_route_table.hoge.id}"
+}
+
+resource "aws_iam_role" "emr_role" {
+  assume_role_policy = <<EOT
+{
+  "Version": "2008-10-17",
+  "Statement": [
+    {
+      "Sid": "",
+      "Effect": "Allow",
+      "Principal": {
+        "Service": "elasticmapreduce.amazonaws.com"
+      },
+      "Action": "sts:AssumeRole"
+    }
+  ]
+}
+EOT
+}
+
+resource "aws_iam_role_policy_attachment" "emr_role" {
+  role       = "${aws_iam_role.emr_role.id}"
+  policy_arn = "${aws_iam_policy.emr_policy.arn}"
+}
+
+resource "aws_iam_policy" "emr_policy" {
+  policy = <<EOT
+{
+  "Version": "2012-10-17",
+  "Statement": [{
+    "Effect": "Allow",
+    "Resource": "*",
+    "Action": [
+      "ec2:AuthorizeSecurityGroupEgress",
+      "ec2:AuthorizeSecurityGroupIngress",
+      "ec2:CancelSpotInstanceRequests",
+      "ec2:CreateNetworkInterface",
+      "ec2:CreateSecurityGroup",
+      "ec2:CreateTags",
+      "ec2:DeleteNetworkInterface",
+      "ec2:DeleteSecurityGroup",
+      "ec2:DeleteTags",
+      "ec2:DescribeAvailabilityZones",
+      "ec2:DescribeAccountAttributes",
+      "ec2:DescribeDhcpOptions",
+      "ec2:DescribeInstanceStatus",
+      "ec2:DescribeInstances",
+      "ec2:DescribeKeyPairs",
+      "ec2:DescribeNetworkAcls",
+      "ec2:DescribeNetworkInterfaces",
+      "ec2:DescribePrefixLists",
+      "ec2:DescribeRouteTables",
+      "ec2:DescribeSecurityGroups",
+      "ec2:DescribeSpotInstanceRequests",
+      "ec2:DescribeSpotPriceHistory",
+      "ec2:DescribeSubnets",
+      "ec2:DescribeVpcAttribute",
+      "ec2:DescribeVpcEndpoints",
+      "ec2:DescribeVpcEndpointServices",
+      "ec2:DescribeVpcs",
+      "ec2:DetachNetworkInterface",
+      "ec2:ModifyImageAttribute",
+      "ec2:ModifyInstanceAttribute",
+      "ec2:RequestSpotInstances",
+      "ec2:RevokeSecurityGroupEgress",
+      "ec2:RunInstances",
+      "ec2:TerminateInstances",
+      "ec2:DeleteVolume",
+      "ec2:DescribeVolumeStatus",
+      "ec2:DescribeVolumes",
+      "ec2:DetachVolume",
+      "iam:GetRole",
+      "iam:GetRolePolicy",
+      "iam:ListInstanceProfiles",
+      "iam:ListRolePolicies",
+      "iam:PassRole",
+      "s3:CreateBucket",
+      "s3:Get*",
+      "s3:List*",
+      "sdb:BatchPutAttributes",
+      "sdb:Select",
+      "sqs:CreateQueue",
+      "sqs:Delete*",
+      "sqs:GetQueue*",
+      "sqs:PurgeQueue",
+      "sqs:ReceiveMessage"
+    ]
+  }]
+}
+EOT
+}
+
+# IAM Role for EC2 Instance Profile
+resource "aws_iam_role" "instance_role" {
+  assume_role_policy = <<EOT
+{
+  "Version": "2008-10-17",
+  "Statement": [
+    {
+      "Sid": "",
+      "Effect": "Allow",
+      "Principal": {
+        "Service": "ec2.amazonaws.com"
+      },
+      "Action": "sts:AssumeRole"
+    }
+  ]
+}
+EOT
+}
+
+resource "aws_iam_instance_profile" "instance_profile" {
+  name = "tf-emr-profile-%s"
+  role = "${aws_iam_role.instance_role.name}"
+}
+
+resource "aws_iam_role_policy_attachment" "instance_role" {
+  role = "${aws_iam_role.instance_role.id}"
+  policy_arn = "${aws_iam_policy.instance_policy.arn}"
+}
+
+resource "aws_iam_policy" "instance_policy" {
+  policy = <<EOT
+{
+  "Version": "2012-10-17",
+  "Statement": [{
+    "Effect": "Allow",
+    "Resource": "*",
+    "Action": [
+      "cloudwatch:*",
+      "dynamodb:*",
+      "ec2:Describe*",
+      "elasticmapreduce:Describe*",
+      "elasticmapreduce:ListBootstrapActions",
+      "elasticmapreduce:ListClusters",
+      "elasticmapreduce:ListInstanceGroups",
+      "elasticmapreduce:ListInstances",
+      "elasticmapreduce:ListSteps",
+      "kinesis:CreateStream",
+      "kinesis:DeleteStream",
+      "kinesis:DescribeStream",
+      "kinesis:GetRecords",
+      "kinesis:GetShardIterator",
+      "kinesis:MergeShards",
+      "kinesis:PutRecord",
+      "kinesis:SplitShard",
+      "rds:Describe*",
+      "s3:*",
+      "sdb:*",
+      "sns:*",
+      "sqs:*"
+    ]
+  }]
+}
+EOT
+}
+
+# IAM Role for autoscaling
+resource "aws_iam_role" "autoscale_role" {
+  assume_role_policy = "${data.aws_iam_policy_document.autoscale_role.json}"
+}
+
+data "aws_iam_policy_document" "autoscale_role" {
+  statement {
+    effect  = "Allow"
+    actions = ["sts:AssumeRole"]
+
+    principals = {
+      type        = "Service"
+      identifiers = ["elasticmapreduce.amazonaws.com","application-autoscaling.amazonaws.com"]
+    }
+  }
+}
+
+resource "aws_iam_role_policy_attachment" "autoscale_role" {
+  role       = "${aws_iam_role.autoscale_role.name}"
+  policy_arn = "arn:aws:iam::aws:policy/service-role/AmazonElasticMapReduceforAutoScalingRole"
+}
+
+resource "aws_appautoscaling_target" "hoge" {
+  service_namespace = "elasticmapreduce"
+  resource_id = "instancegroup/${aws_emr_cluster.hoge.id}/${aws_emr_instance_group.hoge.id}"
+  scalable_dimension = "elasticmapreduce:instancegroup:InstanceCount"
+  role_arn = "${aws_iam_role.autoscale_role.arn}"
+  min_capacity = 1
+  max_capacity = 5
+}
+
+resource "aws_appautoscaling_scheduled_action" "hoge" {
+  name = "tf-appauto-%s"
+  service_namespace = "${aws_appautoscaling_target.hoge.service_namespace}"
+  resource_id = "${aws_appautoscaling_target.hoge.resource_id}"
+  scalable_dimension = "${aws_appautoscaling_target.hoge.scalable_dimension}"
+  schedule = "at(%s)"
+
+  scalable_target_action {
+    min_capacity = 1
+    max_capacity = 5
+  }
+}
+`, rName, rName, rName, rName, ts)
+}
+
+func testAccAppautoscalingScheduledActionConfig_SpotFleet(rName, ts string) string {
+	return fmt.Sprintf(`
+resource "aws_iam_role" "fleet_role" {
+  assume_role_policy = <<EOF
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Principal": {
+        "Service": [
+          "spotfleet.amazonaws.com",
+          "ec2.amazonaws.com"
+        ]
+      },
+      "Action": "sts:AssumeRole"
+    }
+  ]
+}
+EOF
+}
+
+resource "aws_iam_role_policy_attachment" "fleet_role_policy" {
+  role = "${aws_iam_role.fleet_role.name}"
+  policy_arn = "arn:aws:iam::aws:policy/service-role/AmazonEC2SpotFleetRole"
+}
+
+resource "aws_spot_fleet_request" "hoge" {
+  iam_fleet_role = "${aws_iam_role.fleet_role.arn}"
+  spot_price = "0.005"
+  target_capacity = 2
+  valid_until = "2019-11-04T20:44:20Z"
+  terminate_instances_with_expiration = true
+
+  launch_specification {
+    instance_type = "m3.medium"
+    ami = "ami-d06a90b0"
+  }
+}
+
+resource "aws_iam_role" "autoscale_role" {
+  assume_role_policy = <<EOF
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Principal": {
+        "Service": "application-autoscaling.amazonaws.com"
+      },
+      "Action": "sts:AssumeRole"
+    }
+  ]
+}
+EOF
+}
+
+resource "aws_iam_role_policy_attachment" "autoscale_role_policy_a" {
+  role = "${aws_iam_role.autoscale_role.name}"
+  policy_arn = "arn:aws:iam::aws:policy/service-role/AmazonEC2SpotFleetRole"
+}
+
+resource "aws_iam_role_policy_attachment" "autoscale_role_policy_b" {
+  role = "${aws_iam_role.autoscale_role.name}"
+  policy_arn = "arn:aws:iam::aws:policy/service-role/AmazonEC2SpotFleetAutoscaleRole"
+}
+
+resource "aws_appautoscaling_target" "hoge" {
+  service_namespace = "ec2"
+  resource_id = "spot-fleet-request/${aws_spot_fleet_request.hoge.id}"
+  scalable_dimension = "ec2:spot-fleet-request:TargetCapacity"
+  role_arn = "${aws_iam_role.autoscale_role.arn}"
+  min_capacity = 1
+  max_capacity = 3
+}
+
+resource "aws_appautoscaling_scheduled_action" "hoge" {
+  name = "tf-appauto-%s"
+  service_namespace = "${aws_appautoscaling_target.hoge.service_namespace}"
+  resource_id = "${aws_appautoscaling_target.hoge.resource_id}"
+  scalable_dimension = "${aws_appautoscaling_target.hoge.scalable_dimension}"
+  schedule = "at(%s)"
+
+  scalable_target_action {
+    min_capacity = 1
+    max_capacity = 3
+  }
+}
+`, rName, ts)
+}
diff --git a/website/aws.erb b/website/aws.erb
index 71453affcc6..f822a86063d 100644
--- a/website/aws.erb
+++ b/website/aws.erb
@@ -292,7 +292,9 @@
                       <li<%= sidebar_current("docs-aws-resource-appautoscaling-policy") %>>
                         <a href="/docs/providers/aws/r/appautoscaling_policy.html">aws_appautoscaling_policy</a>
                       </li>
-
+                      <li<%= sidebar_current("docs-aws-resource-appautoscaling-scheduled-action") %>>
+                        <a href="/docs/providers/aws/r/appautoscaling_scheduled_action.html">aws_appautoscaling_scheduled_action</a>
+                      </li>
                       <li<%= sidebar_current("docs-aws-resource-appautoscaling-target") %>>
                         <a href="/docs/providers/aws/r/appautoscaling_target.html">aws_appautoscaling_target</a>
                       </li>
diff --git a/website/docs/r/appautoscaling_scheduled_action.html.markdown b/website/docs/r/appautoscaling_scheduled_action.html.markdown
new file mode 100644
index 00000000000..4b300af9b5b
--- /dev/null
+++ b/website/docs/r/appautoscaling_scheduled_action.html.markdown
@@ -0,0 +1,89 @@
+---
+layout: "aws"
+page_title: "AWS: aws_appautoscaling_scheduled_action"
+sidebar_current: "docs-aws-resource-appautoscaling-scheduled-action"
+description: |-
+  Provides an Application AutoScaling ScheduledAction resource.
+---
+
+# aws_appautoscaling_scheduled_action
+
+Provides an Application AutoScaling ScheduledAction resource.
+
+## Example Usage
+
+### DynamoDB Table Autoscaling
+
+```hcl
+resource "aws_appautoscaling_target" "dynamodb" {
+  max_capacity       = 100
+  min_capacity       = 5
+  resource_id        = "table/tableName"
+  role_arn           = "${data.aws_iam_role.DynamoDBAutoscaleRole.arn}"
+  scalable_dimension = "dynamodb:table:ReadCapacityUnits"
+  service_namespace  = "dynamodb"
+}
+
+resource "aws_appautoscaling_scheduled_action" "dynamodb" {
+  name = "dynamodb"
+  service_namespace = "${aws_appautoscaling_target.dynamodb.service_namespace}"
+  resource_id = "${aws_appautoscaling_target.dynamodb.resource_id}"
+  scalable_dimension = "${aws_appautoscaling_target.dynamodb.scalable_dimension}"
+  schedule = "at(2006-01-02T15:04:05)"
+
+  scalable_target_action {
+    min_capacity = 1
+    max_capacity = 200
+  }
+}
+```
+
+### ECS Service Autoscaling
+
+```hcl
+resource "aws_appautoscaling_target" "ecs" {
+  max_capacity       = 4
+  min_capacity       = 1
+  resource_id        = "service/clusterName/serviceName"
+  role_arn           = "${var.ecs_iam_role}"
+  scalable_dimension = "ecs:service:DesiredCount"
+  service_namespace  = "ecs"
+}
+
+resource "aws_appautoscaling_scheduled_action" "ecs" {
+  name = "ecs"
+  service_namespace = "${aws_appautoscaling_target.ecs.service_namespace}"
+  resource_id = "${aws_appautoscaling_target.ecs.resource_id}"
+  scalable_dimension = "${aws_appautoscaling_target.ecs.scalable_dimension}"
+  schedule = "at(2006-01-02T15:04:05)"
+
+  scalable_target_action {
+    min_capacity = 1
+    max_capacity = 10
+  }
+}
+```
+
+## Argument Reference
+
+The following arguments are supported:
+
+* `name` - (Required) The name of the scheduled action.
+* `service_namespace` - (Required) The namespace of the AWS service. Documentation can be found in the parameter at: [AWS Application Auto Scaling API Reference](https://docs.aws.amazon.com/ApplicationAutoScaling/latest/APIReference/API_PutScheduledAction.html#ApplicationAutoScaling-PutScheduledAction-request-ServiceNamespace) Example: ecs
+* `resource_id` - (Required) The identifier of the resource associated with the scheduled action. Documentation can be found in the parameter at: [AWS Application Auto Scaling API Reference](https://docs.aws.amazon.com/ApplicationAutoScaling/latest/APIReference/API_PutScheduledAction.html#ApplicationAutoScaling-PutScheduledAction-request-ResourceId)
+* `scalable_dimension` - (Optional) The scalable dimension. Documentation can be found in the parameter at: [AWS Application Auto Scaling API Reference](https://docs.aws.amazon.com/ApplicationAutoScaling/latest/APIReference/API_PutScheduledAction.html#ApplicationAutoScaling-PutScheduledAction-request-ScalableDimension) Example: ecs:service:DesiredCount
+* `scalable_target_action` - (Optional) The new minimum and maximum capacity. You can set both values or just one. See [below](#scalable-target-action-arguments)
+* `schedule` - (Optional) The schedule for this action. The following formats are supported: At expressions - at(yyyy-mm-ddThh:mm:ss), Rate expressions - rate(valueunit), Cron expressions - cron(fields). In UTC. Documentation can be found in the parameter at: [AWS Application Auto Scaling API Reference](https://docs.aws.amazon.com/ApplicationAutoScaling/latest/APIReference/API_PutScheduledAction.html#ApplicationAutoScaling-PutScheduledAction-request-Schedule)
+* `start_time` - (Optional) The date and time for the scheduled action to start. Specify the following format: 2006-01-02T15:04:05Z
+* `end_time` - (Optional) The date and time for the scheduled action to end. Specify the following format: 2006-01-02T15:04:05Z
+
+### Scalable Target Action Arguments
+
+* `max_capacity` - (Optional) The maximum capacity.
+* `min_capacity` - (Optional) The minimum capacity.
+
+## Attributes Reference
+
+The following attributes are exported:
+
+* `arn` - The Amazon Resource Name (ARN) of the scheduled action.