diff --git a/.autover/changes/add-scheduleevent-annotation.json b/.autover/changes/add-scheduleevent-annotation.json
new file mode 100644
index 000000000..dc25a283f
--- /dev/null
+++ b/.autover/changes/add-scheduleevent-annotation.json
@@ -0,0 +1,11 @@
+{
+  "Projects": [
+    {
+      "Name": "Amazon.Lambda.Annotations",
+      "Type": "Minor",
+      "ChangelogMessages": [
+        "Added [ScheduleEvent] annotation attribute for declaratively configuring schedule-triggered Lambda functions with support for rate and cron expressions, description, input, and enabled state."
+      ]
+    }
+  ]
+}
diff --git a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Diagnostics/AnalyzerReleases.Unshipped.md b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Diagnostics/AnalyzerReleases.Unshipped.md
index d1a9a89d0..e6cb14ac1 100644
--- a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Diagnostics/AnalyzerReleases.Unshipped.md
+++ b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Diagnostics/AnalyzerReleases.Unshipped.md
@@ -21,3 +21,4 @@ AWSLambda0133 | AWSLambdaCSharpGenerator | Error | ALB Listener Reference Not Fo
 AWSLambda0134 | AWSLambdaCSharpGenerator | Error | FromRoute not supported on ALB functions
 AWSLambda0135 | AWSLambdaCSharpGenerator | Error | Unmapped parameter on ALB function
 AWSLambda0136 | AWSLambdaCSharpGenerator | Error | Invalid S3EventAttribute
+AWSLambda0139 | AWSLambdaCSharpGenerator | Error | Invalid ScheduleEventAttribute
diff --git a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Diagnostics/DiagnosticDescriptors.cs b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Diagnostics/DiagnosticDescriptors.cs
index e1a11087f..eae205078 100644
--- a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Diagnostics/DiagnosticDescriptors.cs
+++ b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Diagnostics/DiagnosticDescriptors.cs
@@ -281,5 +281,12 @@ public static class DiagnosticDescriptors
             category: "AWSLambdaCSharpGenerator",
             DiagnosticSeverity.Error,
             isEnabledByDefault: true);
+
+        public static readonly DiagnosticDescriptor InvalidScheduleEventAttribute = new DiagnosticDescriptor(id: "AWSLambda0139",
+            title: "Invalid ScheduleEventAttribute",
+            messageFormat: "Invalid ScheduleEventAttribute encountered: {0}",
+            category: "AWSLambdaCSharpGenerator",
+            DiagnosticSeverity.Error,
+            isEnabledByDefault: true);
     }
 }
diff --git a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Models/Attributes/AttributeModelBuilder.cs b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Models/Attributes/AttributeModelBuilder.cs
index 0d1067bb6..ca00e8db1 100644
--- a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Models/Attributes/AttributeModelBuilder.cs
+++ b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Models/Attributes/AttributeModelBuilder.cs
@@ -1,5 +1,6 @@
 using System;
 using Amazon.Lambda.Annotations.ALB;
+using Amazon.Lambda.Annotations.Schedule;
 using Amazon.Lambda.Annotations.APIGateway;
 using Amazon.Lambda.Annotations.S3;
 using Amazon.Lambda.Annotations.SQS;
@@ -101,6 +102,15 @@ public static AttributeModel Build(AttributeData att, GeneratorExecutionContext
                     Type = TypeModelBuilder.Build(att.AttributeClass, context)
                 };
             }
+            else if (att.AttributeClass.Equals(context.Compilation.GetTypeByMetadataName(TypeFullNames.ScheduleEventAttribute), SymbolEqualityComparer.Default))
+            {
+                var data = ScheduleEventAttributeBuilder.Build(att);
+                model = new AttributeModel<ScheduleEventAttribute>
+                {
+                    Data = data,
+                    Type = TypeModelBuilder.Build(att.AttributeClass, context)
+                };
+            }
             else if (att.AttributeClass.Equals(context.Compilation.GetTypeByMetadataName(TypeFullNames.HttpApiAuthorizerAttribute), SymbolEqualityComparer.Default))
             {
                 var data = HttpApiAuthorizerAttributeBuilder.Build(att);
diff --git a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Models/Attributes/ScheduleEventAttributeBuilder.cs b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Models/Attributes/ScheduleEventAttributeBuilder.cs
new file mode 100644
index 000000000..a7a03237d
--- /dev/null
+++ b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Models/Attributes/ScheduleEventAttributeBuilder.cs
@@ -0,0 +1,44 @@
+using Amazon.Lambda.Annotations.Schedule;
+using Microsoft.CodeAnalysis;
+using System;
+
+namespace Amazon.Lambda.Annotations.SourceGenerator.Models.Attributes
+{
+    /// <summary>
+    /// Builder for <see cref="ScheduleEventAttribute"/>.
+    /// </summary>
+    public class ScheduleEventAttributeBuilder
+    {
+        public static ScheduleEventAttribute Build(AttributeData att)
+        {
+            if (att.ConstructorArguments.Length != 1)
+            {
+                throw new NotSupportedException($"{TypeFullNames.ScheduleEventAttribute} must have constructor with 1 argument.");
+            }
+            var schedule = att.ConstructorArguments[0].Value as string;
+            var data = new ScheduleEventAttribute(schedule);
+
+            foreach (var pair in att.NamedArguments)
+            {
+                if (pair.Key == nameof(data.ResourceName) && pair.Value.Value is string resourceName)
+                {
+                    data.ResourceName = resourceName;
+                }
+                else if (pair.Key == nameof(data.Description) && pair.Value.Value is string description)
+                {
+                    data.Description = description;
+                }
+                else if (pair.Key == nameof(data.Input) && pair.Value.Value is string input)
+                {
+                    data.Input = input;
+                }
+                else if (pair.Key == nameof(data.Enabled) && pair.Value.Value is bool enabled)
+                {
+                    data.Enabled = enabled;
+                }
+            }
+
+            return data;
+        }
+    }
+}
diff --git a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Models/EventTypeBuilder.cs b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Models/EventTypeBuilder.cs
index 3dfc51799..ca827b9c6 100644
--- a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Models/EventTypeBuilder.cs
+++ b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Models/EventTypeBuilder.cs
@@ -30,6 +30,10 @@ public static HashSet<EventType> Build(IMethodSymbol lambdaMethodSymbol,
                 {
                     events.Add(EventType.S3);
                 }
+                else if (attribute.AttributeClass.ToDisplayString() == TypeFullNames.ScheduleEventAttribute)
+                {
+                    events.Add(EventType.Schedule);
+                }
                 else if (attribute.AttributeClass.ToDisplayString() == TypeFullNames.HttpApiAuthorizerAttribute
                     || attribute.AttributeClass.ToDisplayString() == TypeFullNames.RestApiAuthorizerAttribute)
                 {
diff --git a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/SyntaxReceiver.cs b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/SyntaxReceiver.cs
index 2091d6c94..8198ecf0b 100644
--- a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/SyntaxReceiver.cs
+++ b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/SyntaxReceiver.cs
@@ -23,7 +23,8 @@ internal class SyntaxReceiver : ISyntaxContextReceiver
             { "RestApiAttribute", "RestApi" },
             { "SQSEventAttribute", "SQSEvent" },
             { "ALBApiAttribute", "ALBApi" },
-            { "S3EventAttribute", "S3Event" }
+            { "S3EventAttribute", "S3Event" },
+            { "ScheduleEventAttribute", "ScheduleEvent" }
         };
 
         public List<MethodDeclarationSyntax> LambdaMethods { get; } = new List<MethodDeclarationSyntax>();
diff --git a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/TypeFullNames.cs b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/TypeFullNames.cs
index 59fa1d830..2db1a8e45 100644
--- a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/TypeFullNames.cs
+++ b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/TypeFullNames.cs
@@ -56,6 +56,9 @@ public static class TypeFullNames
         public const string S3Event = "Amazon.Lambda.S3Events.S3Event";
         public const string S3EventAttribute = "Amazon.Lambda.Annotations.S3.S3EventAttribute";
 
+        public const string ScheduledEvent = "Amazon.Lambda.CloudWatchEvents.ScheduledEvents.ScheduledEvent";
+        public const string ScheduleEventAttribute = "Amazon.Lambda.Annotations.Schedule.ScheduleEventAttribute";
+
         public const string LambdaSerializerAttribute = "Amazon.Lambda.Core.LambdaSerializerAttribute";
         public const string DefaultLambdaSerializer = "Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer";
 
@@ -84,7 +87,8 @@ public static class TypeFullNames
             HttpApiAttribute,
             SQSEventAttribute,
             ALBApiAttribute,
-            S3EventAttribute
+            S3EventAttribute,
+            ScheduleEventAttribute
         };
     }
 }
\ No newline at end of file
diff --git a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Validation/LambdaFunctionValidator.cs b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Validation/LambdaFunctionValidator.cs
index 7e728660a..8b6d8b18a 100644
--- a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Validation/LambdaFunctionValidator.cs
+++ b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Validation/LambdaFunctionValidator.cs
@@ -4,6 +4,7 @@
 using Amazon.Lambda.Annotations.SourceGenerator.Extensions;
 using Amazon.Lambda.Annotations.SourceGenerator.Models;
 using Amazon.Lambda.Annotations.SourceGenerator.Models.Attributes;
+using Amazon.Lambda.Annotations.Schedule;
 using Amazon.Lambda.Annotations.SQS;
 using Microsoft.CodeAnalysis;
 using System.Collections.Generic;
@@ -61,6 +62,7 @@ internal static bool ValidateFunction(GeneratorExecutionContext context, IMethod
             // Validate Events
             ValidateApiGatewayEvents(lambdaFunctionModel, methodLocation, diagnostics);
             ValidateSqsEvents(lambdaFunctionModel, methodLocation, diagnostics);
+            ValidateScheduleEvents(lambdaFunctionModel, methodLocation, diagnostics);
             ValidateAlbEvents(lambdaFunctionModel, methodLocation, diagnostics);
             ValidateS3Events(lambdaFunctionModel, methodLocation, diagnostics);
 
@@ -110,6 +112,16 @@ internal static bool ValidateDependencies(GeneratorExecutionContext context, IMe
                 }
             }
 
+            // Check for references to "Amazon.Lambda.CloudWatchEvents" if the Lambda method is annotated with ScheduleEvent attribute.
+            if (lambdaMethodSymbol.HasAttribute(context, TypeFullNames.ScheduleEventAttribute))
+            {
+                if (context.Compilation.ReferencedAssemblyNames.FirstOrDefault(x => x.Name == "Amazon.Lambda.CloudWatchEvents") == null)
+                {
+                    diagnosticReporter.Report(Diagnostic.Create(DiagnosticDescriptors.MissingDependencies, methodLocation, "Amazon.Lambda.CloudWatchEvents"));
+                    return false;
+                }
+            }
+
             return true;
         }
 
@@ -420,6 +432,43 @@ private static void ValidateS3Events(LambdaFunctionModel lambdaFunctionModel, Lo
             }
         }
 
+        private static void ValidateScheduleEvents(LambdaFunctionModel lambdaFunctionModel, Location methodLocation, List<Diagnostic> diagnostics)
+        {
+            if (!lambdaFunctionModel.LambdaMethod.Events.Contains(EventType.Schedule))
+            {
+                return;
+            }
+
+            foreach (var att in lambdaFunctionModel.Attributes)
+            {
+                if (att.Type.FullName != TypeFullNames.ScheduleEventAttribute)
+                    continue;
+
+                var scheduleEventAttribute = ((AttributeModel<ScheduleEventAttribute>)att).Data;
+                var validationErrors = scheduleEventAttribute.Validate();
+                validationErrors.ForEach(errorMessage => diagnostics.Add(Diagnostic.Create(DiagnosticDescriptors.InvalidScheduleEventAttribute, methodLocation, errorMessage)));
+            }
+
+            // Validate method parameters
+            var parameters = lambdaFunctionModel.LambdaMethod.Parameters;
+            if (parameters.Count > 2 ||
+                (parameters.Count >= 1 && parameters[0].Type.FullName != TypeFullNames.ScheduledEvent) ||
+                (parameters.Count == 2 && parameters[1].Type.FullName != TypeFullNames.ILambdaContext))
+            {
+                var errorMessage = $"When using the {nameof(ScheduleEventAttribute)}, the Lambda method can accept at most 2 parameters. " +
+                    $"The first parameter must be of type {TypeFullNames.ScheduledEvent}. " +
+                    $"The second parameter is optional and must be of type {TypeFullNames.ILambdaContext}.";
+                diagnostics.Add(Diagnostic.Create(DiagnosticDescriptors.InvalidLambdaMethodSignature, methodLocation, errorMessage));
+            }
+
+            // Validate return type - must be void or Task
+            if (!lambdaFunctionModel.LambdaMethod.ReturnsVoid && !lambdaFunctionModel.LambdaMethod.ReturnsVoidTask)
+            {
+                var errorMessage = $"When using the {nameof(ScheduleEventAttribute)}, the Lambda method can return either void or {TypeFullNames.Task}";
+                diagnostics.Add(Diagnostic.Create(DiagnosticDescriptors.InvalidLambdaMethodSignature, methodLocation, errorMessage));
+            }
+        }
+
         private static bool ReportDiagnostics(DiagnosticReporter diagnosticReporter, List<Diagnostic> diagnostics)
         {
             var isValid = true;
diff --git a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Writers/CloudFormationWriter.cs b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Writers/CloudFormationWriter.cs
index a72e3241b..a230a78ce 100644
--- a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Writers/CloudFormationWriter.cs
+++ b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Writers/CloudFormationWriter.cs
@@ -3,6 +3,7 @@
 using Amazon.Lambda.Annotations.SourceGenerator.Diagnostics;
 using Amazon.Lambda.Annotations.SourceGenerator.FileIO;
 using Amazon.Lambda.Annotations.SourceGenerator.Models;
+using Amazon.Lambda.Annotations.Schedule;
 using Amazon.Lambda.Annotations.SourceGenerator.Models.Attributes;
 using Amazon.Lambda.Annotations.S3;
 using Amazon.Lambda.Annotations.SQS;
@@ -232,6 +233,10 @@ private void ProcessLambdaFunctionEventAttributes(ILambdaFunctionSerializable la
                         eventName = ProcessS3Attribute(lambdaFunction, s3AttributeModel.Data, currentSyncedEventProperties);
                         currentSyncedEvents.Add(eventName);
                         break;
+                    case AttributeModel<ScheduleEventAttribute> scheduleAttributeModel:
+                        eventName = ProcessScheduleAttribute(lambdaFunction, scheduleAttributeModel.Data, currentSyncedEventProperties);
+                        currentSyncedEvents.Add(eventName);
+                        break;
                 }
             }
 
@@ -608,6 +613,40 @@ private string ProcessSqsAttribute(ILambdaFunctionSerializable lambdaFunction, S
             return att.ResourceName;
         }
 
+        /// <summary>
+        /// Writes all properties associated with <see cref="ScheduleEventAttribute"/> to the serverless template.
+        /// </summary>
+        private string ProcessScheduleAttribute(ILambdaFunctionSerializable lambdaFunction, ScheduleEventAttribute att, Dictionary<string, List<string>> syncedEventProperties)
+        {
+            var eventName = att.ResourceName;
+            var eventPath = $"Resources.{lambdaFunction.ResourceName}.Properties.Events.{eventName}";
+
+            _templateWriter.SetToken($"{eventPath}.Type", "Schedule");
+
+            // Schedule expression
+            SetEventProperty(syncedEventProperties, lambdaFunction.ResourceName, eventName, "Schedule", att.Schedule);
+
+            // Description
+            if (att.IsDescriptionSet)
+            {
+                SetEventProperty(syncedEventProperties, lambdaFunction.ResourceName, eventName, "Description", att.Description);
+            }
+
+            // Input
+            if (att.IsInputSet)
+            {
+                SetEventProperty(syncedEventProperties, lambdaFunction.ResourceName, eventName, "Input", att.Input);
+            }
+
+            // Enabled
+            if (att.IsEnabledSet)
+            {
+                SetEventProperty(syncedEventProperties, lambdaFunction.ResourceName, eventName, "Enabled", att.Enabled);
+            }
+
+            return att.ResourceName;
+        }
+
         /// <summary>
         /// Writes all properties associated with <see cref="S3EventAttribute"/> to the serverless template.
         /// </summary>
diff --git a/Libraries/src/Amazon.Lambda.Annotations/README.md b/Libraries/src/Amazon.Lambda.Annotations/README.md
index d736e06be..be573af3d 100644
--- a/Libraries/src/Amazon.Lambda.Annotations/README.md
+++ b/Libraries/src/Amazon.Lambda.Annotations/README.md
@@ -19,6 +19,7 @@ Topics:
   - [Amazon API Gateway example](#amazon-api-gateway-example)
   - [Amazon S3 example](#amazon-s3-example)
   - [SQS Event Example](#sqs-event-example)
+  - [Schedule Event Example](#schedule-event-example)
   - [Application Load Balancer (ALB) Example](#application-load-balancer-alb-example)
   - [Custom Lambda Authorizer Example](#custom-lambda-authorizer-example)
     - [HTTP API Authorizer](#http-api-authorizer)
@@ -1073,6 +1074,25 @@ The `ALBApi` attribute requires an existing ALB listener. Here is a minimal exam
 
 Then your Lambda function references `@MyListener` in the `ALBApi` attribute.
 
+## Schedule Event Example
+This example shows how to use the `ScheduleEvent` attribute to trigger a Lambda function on a schedule using EventBridge.
+
+The `ScheduleEvent` attribute contains the following properties:
+* **Schedule** (Required) - The schedule expression. Supports `rate()` and `cron()` expressions (e.g. `rate(5 minutes)`, `cron(0 12 * * ? *)`).
+* **ResourceName** (Optional) - The CloudFormation resource name for the schedule event.
+* **Description** (Optional) - A description for the schedule rule.
+* **Input** (Optional) - A JSON string to pass as input to the Lambda function.
+* **Enabled** (Optional) - If false, the schedule rule is disabled. Default is true.
+
+```csharp
+[LambdaFunction(ResourceName = "ScheduledHandler", Policies = "AWSLambdaBasicExecutionRole")]
+[ScheduleEvent("rate(5 minutes)", ResourceName = "FiveMinuteSchedule", Description = "Runs every 5 minutes")]
+public void HandleSchedule(ScheduledEvent evnt, ILambdaContext lambdaContext)
+{
+    lambdaContext.Logger.Log($"Scheduled event received at {evnt.Time}");
+}
+```
+
 ## Custom Lambda Authorizer Example
 
 Lambda Annotations supports defining custom Lambda authorizers using attributes. Custom authorizers let you control access to your API Gateway endpoints by running a Lambda function that validates tokens or request parameters before the target function is invoked. The source generator automatically wires up the authorizer resources and references in the CloudFormation template.
@@ -1420,6 +1440,8 @@ parameter to the `LambdaFunction` must be the event object and the event source
     * Marks a Lambda function as a REST API (API Gateway V1) custom authorizer. The authorizer name is automatically derived from the method name. Other functions reference it via `RestApi.Authorizer` using `nameof()`. Use the `Type` property to choose between `Token` and `Request` authorizer types.
 * SQSEvent
     * Sets up event source mapping between the Lambda function and SQS queues. The SQS queue ARN is required to be set on the attribute. If users want to pass a reference to an existing SQS queue resource defined in their CloudFormation template, they can pass the SQS queue resource name prefixed with the '@' symbol.
+* ScheduleEvent
+    * Triggers the Lambda function on a schedule using EventBridge. Supports rate and cron expressions.
 * ALBApi
     * Configures the Lambda function to be called from an Application Load Balancer. The listener ARN (or `@ResourceName` template reference), path pattern, and priority are required. The source generator creates standalone CloudFormation resources (TargetGroup, ListenerRule, Lambda Permission) rather than SAM event types.
 
diff --git a/Libraries/src/Amazon.Lambda.Annotations/Schedule/ScheduleEventAttribute.cs b/Libraries/src/Amazon.Lambda.Annotations/Schedule/ScheduleEventAttribute.cs
new file mode 100644
index 000000000..0ef7cde51
--- /dev/null
+++ b/Libraries/src/Amazon.Lambda.Annotations/Schedule/ScheduleEventAttribute.cs
@@ -0,0 +1,96 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+namespace Amazon.Lambda.Annotations.Schedule
+{
+    /// <summary>
+    /// This attribute defines the Schedule event source configuration for a Lambda function.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
+    public class ScheduleEventAttribute : Attribute
+    {
+        private static readonly Regex _resourceNameRegex = new Regex("^[a-zA-Z0-9]+$");
+
+        /// <summary>
+        /// The schedule expression. Supports rate and cron expressions.
+        /// Examples: "rate(5 minutes)", "cron(0 12 * * ? *)"
+        /// </summary>
+        public string Schedule { get; set; }
+
+        /// <summary>
+        /// The CloudFormation resource name for the schedule event.
+        /// </summary>
+        public string ResourceName
+        {
+            get
+            {
+                if (IsResourceNameSet)
+                {
+                    return resourceName;
+                }
+                // Generate a default resource name from the schedule expression
+                var sanitized = string.Join(string.Empty, Schedule.Where(char.IsLetterOrDigit));
+                return sanitized.Length > 0 ? sanitized : "ScheduleEvent";
+            }
+            set => resourceName = value;
+        }
+
+        private string resourceName { get; set; } = null;
+        internal bool IsResourceNameSet => resourceName != null;
+
+        /// <summary>
+        /// A description for the schedule rule.
+        /// </summary>
+        public string Description { get; set; } = null;
+        internal bool IsDescriptionSet => Description != null;
+
+        /// <summary>
+        /// A JSON string to pass as input to the Lambda function.
+        /// </summary>
+        public string Input { get; set; } = null;
+        internal bool IsInputSet => Input != null;
+
+        /// <summary>
+        /// If set to false, the event source mapping will be disabled. Default value is true.
+        /// </summary>
+        public bool Enabled
+        {
+            get => enabled.GetValueOrDefault();
+            set => enabled = value;
+        }
+        private bool? enabled { get; set; }
+        internal bool IsEnabledSet => enabled.HasValue;
+
+        /// <summary>
+        /// Creates an instance of the <see cref="ScheduleEventAttribute"/> class.
+        /// </summary>
+        /// <param name="schedule"><see cref="Schedule"/> property</param>
+        public ScheduleEventAttribute(string schedule)
+        {
+            Schedule = schedule;
+        }
+
+        internal List<string> Validate()
+        {
+            var validationErrors = new List<string>();
+
+            if (string.IsNullOrEmpty(Schedule))
+            {
+                validationErrors.Add($"{nameof(ScheduleEventAttribute.Schedule)} must not be null or empty");
+            }
+            else if (!Schedule.StartsWith("rate(") && !Schedule.StartsWith("cron("))
+            {
+                validationErrors.Add($"{nameof(ScheduleEventAttribute.Schedule)} = {Schedule}. It must start with 'rate(' or 'cron('");
+            }
+
+            if (IsResourceNameSet && !_resourceNameRegex.IsMatch(ResourceName))
+            {
+                validationErrors.Add($"{nameof(ScheduleEventAttribute.ResourceName)} = {ResourceName}. It must only contain alphanumeric characters and must not be an empty string");
+            }
+
+            return validationErrors;
+        }
+    }
+}
diff --git a/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/Amazon.Lambda.Annotations.SourceGenerators.Tests.csproj b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/Amazon.Lambda.Annotations.SourceGenerators.Tests.csproj
index 56da7d597..d3fcd44c4 100644
--- a/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/Amazon.Lambda.Annotations.SourceGenerators.Tests.csproj
+++ b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/Amazon.Lambda.Annotations.SourceGenerators.Tests.csproj
@@ -208,6 +208,7 @@
       <ProjectReference Include="..\..\src\Amazon.Lambda.Annotations\Amazon.Lambda.Annotations.csproj" />
       <ProjectReference Include="..\..\src\Amazon.Lambda.APIGatewayEvents\Amazon.Lambda.APIGatewayEvents.csproj" />
       <ProjectReference Include="..\..\src\Amazon.Lambda.SQSEvents\Amazon.Lambda.SQSEvents.csproj" />
+      <ProjectReference Include="..\..\src\Amazon.Lambda.CloudWatchEvents\Amazon.Lambda.CloudWatchEvents.csproj" />
       <ProjectReference Include="..\..\src\Amazon.Lambda.ApplicationLoadBalancerEvents\Amazon.Lambda.ApplicationLoadBalancerEvents.csproj" />
       <ProjectReference Include="..\..\src\Amazon.Lambda.S3Events\Amazon.Lambda.S3Events.csproj" />
       <!-- 
diff --git a/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/CSharpSourceGeneratorVerifier.cs b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/CSharpSourceGeneratorVerifier.cs
index 63d122bf2..e07aeb776 100644
--- a/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/CSharpSourceGeneratorVerifier.cs
+++ b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/CSharpSourceGeneratorVerifier.cs
@@ -3,6 +3,7 @@
 using Amazon.Lambda.Core;
 using Amazon.Lambda.RuntimeSupport;
 using Amazon.Lambda.Serialization.SystemTextJson;
+using Amazon.Lambda.CloudWatchEvents.ScheduledEvents;
 using Amazon.Lambda.ApplicationLoadBalancerEvents;
 using Amazon.Lambda.SQSEvents;
 using Microsoft.CodeAnalysis;
@@ -58,6 +59,7 @@ public Test(ReferencesMode referencesMode = ReferencesMode.All, TargetFramework
                     {
                         return solution.AddMetadataReference(projectId, MetadataReference.CreateFromFile(typeof(ILambdaContext).Assembly.Location))
                             .AddMetadataReference(projectId, MetadataReference.CreateFromFile(typeof(APIGatewayProxyRequest).Assembly.Location))
+                            .AddMetadataReference(projectId, MetadataReference.CreateFromFile(typeof(ScheduledEvent).Assembly.Location))
                             .AddMetadataReference(projectId, MetadataReference.CreateFromFile(typeof(SQSEvent).Assembly.Location))
                             .AddMetadataReference(projectId, MetadataReference.CreateFromFile(typeof(ApplicationLoadBalancerRequest).Assembly.Location))
                             .AddMetadataReference(projectId, MetadataReference.CreateFromFile(typeof(IServiceCollection).Assembly.Location))
diff --git a/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/ScheduleEventAttributeTests.cs b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/ScheduleEventAttributeTests.cs
new file mode 100644
index 000000000..5036d2cf7
--- /dev/null
+++ b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/ScheduleEventAttributeTests.cs
@@ -0,0 +1,239 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+using Amazon.Lambda.Annotations.Schedule;
+using Xunit;
+
+namespace Amazon.Lambda.Annotations.SourceGenerators.Tests
+{
+    public class ScheduleEventAttributeTests
+    {
+        // ===== Constructor and Default Values =====
+
+        [Fact]
+        public void Constructor_SetsScheduleProperty()
+        {
+            var attr = new ScheduleEventAttribute("rate(5 minutes)");
+
+            Assert.Equal("rate(5 minutes)", attr.Schedule);
+        }
+
+        [Fact]
+        public void DefaultValues_AreCorrect()
+        {
+            var attr = new ScheduleEventAttribute("rate(5 minutes)");
+
+            Assert.False(attr.IsEnabledSet);
+            Assert.Null(attr.Description);
+            Assert.False(attr.IsDescriptionSet);
+            Assert.Null(attr.Input);
+            Assert.False(attr.IsInputSet);
+            Assert.False(attr.IsResourceNameSet);
+            Assert.Equal("rate5minutes", attr.ResourceName);
+        }
+
+        // ===== ResourceName Tests =====
+
+        [Fact]
+        public void ResourceName_DerivedFromScheduleExpression()
+        {
+            var attr = new ScheduleEventAttribute("rate(1 hour)");
+
+            Assert.False(attr.IsResourceNameSet);
+            Assert.Equal("rate1hour", attr.ResourceName);
+        }
+
+        [Fact]
+        public void ResourceName_DerivedFromCronExpression()
+        {
+            var attr = new ScheduleEventAttribute("cron(0 12 * * ? *)");
+
+            Assert.False(attr.IsResourceNameSet);
+            Assert.Equal("cron012", attr.ResourceName);
+        }
+
+        [Fact]
+        public void ResourceName_WhenExplicitlySet_IsTracked()
+        {
+            var attr = new ScheduleEventAttribute("rate(5 minutes)");
+
+            Assert.False(attr.IsResourceNameSet);
+
+            attr.ResourceName = "CustomSchedule";
+            Assert.True(attr.IsResourceNameSet);
+            Assert.Equal("CustomSchedule", attr.ResourceName);
+        }
+
+        // ===== Description Tests =====
+
+        [Fact]
+        public void Description_DefaultIsNull()
+        {
+            var attr = new ScheduleEventAttribute("rate(5 minutes)");
+
+            Assert.Null(attr.Description);
+            Assert.False(attr.IsDescriptionSet);
+        }
+
+        [Fact]
+        public void Description_WhenSet_IsTracked()
+        {
+            var attr = new ScheduleEventAttribute("rate(5 minutes)")
+            {
+                Description = "Run every 5 minutes"
+            };
+
+            Assert.True(attr.IsDescriptionSet);
+            Assert.Equal("Run every 5 minutes", attr.Description);
+        }
+
+        // ===== Input Tests =====
+
+        [Fact]
+        public void Input_DefaultIsNull()
+        {
+            var attr = new ScheduleEventAttribute("rate(5 minutes)");
+
+            Assert.Null(attr.Input);
+            Assert.False(attr.IsInputSet);
+        }
+
+        [Fact]
+        public void Input_WhenSet_IsTracked()
+        {
+            var attr = new ScheduleEventAttribute("rate(5 minutes)")
+            {
+                Input = "{\"key\": \"value\"}"
+            };
+
+            Assert.True(attr.IsInputSet);
+            Assert.Equal("{\"key\": \"value\"}", attr.Input);
+        }
+
+        // ===== Enabled Property Tests =====
+
+        [Fact]
+        public void Enabled_DefaultNotSet()
+        {
+            var attr = new ScheduleEventAttribute("rate(5 minutes)");
+
+            Assert.False(attr.IsEnabledSet);
+        }
+
+        [Fact]
+        public void Enabled_WhenSetToFalse_IsTracked()
+        {
+            var attr = new ScheduleEventAttribute("rate(5 minutes)")
+            {
+                Enabled = false
+            };
+
+            Assert.True(attr.IsEnabledSet);
+            Assert.False(attr.Enabled);
+        }
+
+        [Fact]
+        public void Enabled_WhenSetToTrue_IsTracked()
+        {
+            var attr = new ScheduleEventAttribute("rate(5 minutes)")
+            {
+                Enabled = true
+            };
+
+            Assert.True(attr.IsEnabledSet);
+            Assert.True(attr.Enabled);
+        }
+
+        // ===== Validation Tests =====
+
+        [Fact]
+        public void Validate_ValidRateExpression_ReturnsNoErrors()
+        {
+            var attr = new ScheduleEventAttribute("rate(5 minutes)");
+
+            var errors = attr.Validate();
+            Assert.Empty(errors);
+        }
+
+        [Fact]
+        public void Validate_ValidCronExpression_ReturnsNoErrors()
+        {
+            var attr = new ScheduleEventAttribute("cron(0 12 * * ? *)");
+
+            var errors = attr.Validate();
+            Assert.Empty(errors);
+        }
+
+        [Fact]
+        public void Validate_NullSchedule_ReturnsError()
+        {
+            var attr = new ScheduleEventAttribute(null);
+
+            var errors = attr.Validate();
+            Assert.Single(errors);
+            Assert.Contains("Schedule", errors[0]);
+        }
+
+        [Fact]
+        public void Validate_EmptySchedule_ReturnsError()
+        {
+            var attr = new ScheduleEventAttribute("");
+
+            var errors = attr.Validate();
+            Assert.Single(errors);
+            Assert.Contains("Schedule", errors[0]);
+        }
+
+        [Fact]
+        public void Validate_InvalidScheduleExpression_ReturnsError()
+        {
+            var attr = new ScheduleEventAttribute("every 5 minutes");
+
+            var errors = attr.Validate();
+            Assert.Single(errors);
+            Assert.Contains("Schedule", errors[0]);
+            Assert.Contains("rate(", errors[0]);
+        }
+
+        [Fact]
+        public void Validate_InvalidResourceName_ReturnsError()
+        {
+            var attr = new ScheduleEventAttribute("rate(5 minutes)")
+            {
+                ResourceName = "invalid-name!"
+            };
+
+            var errors = attr.Validate();
+            Assert.Single(errors);
+            Assert.Contains("ResourceName", errors[0]);
+            Assert.Contains("alphanumeric", errors[0]);
+        }
+
+        [Fact]
+        public void Validate_MultipleErrors_ReturnsAll()
+        {
+            var attr = new ScheduleEventAttribute("invalid")
+            {
+                ResourceName = "invalid!"
+            };
+
+            var errors = attr.Validate();
+            Assert.Equal(2, errors.Count);
+        }
+
+        [Fact]
+        public void Validate_AllValidWithOptionals_ReturnsNoErrors()
+        {
+            var attr = new ScheduleEventAttribute("rate(1 hour)")
+            {
+                ResourceName = "MySchedule",
+                Description = "Hourly job",
+                Input = "{\"action\": \"cleanup\"}",
+                Enabled = true
+            };
+
+            var errors = attr.Validate();
+            Assert.Empty(errors);
+        }
+    }
+}
diff --git a/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/Snapshots/Schedule/ValidScheduleEvents_ProcessScheduledEventAsync_Generated.g.cs b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/Snapshots/Schedule/ValidScheduleEvents_ProcessScheduledEventAsync_Generated.g.cs
new file mode 100644
index 000000000..53b9b43b0
--- /dev/null
+++ b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/Snapshots/Schedule/ValidScheduleEvents_ProcessScheduledEventAsync_Generated.g.cs
@@ -0,0 +1,57 @@
+// <auto-generated/>
+
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using System.IO;
+using Amazon.Lambda.Core;
+
+namespace TestServerlessApp.ScheduleEventExamples
+{
+    public class ValidScheduleEvents_ProcessScheduledEventAsync_Generated
+    {
+        private readonly ValidScheduleEvents validScheduleEvents;
+        private readonly Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer serializer;
+
+        /// <summary>
+        /// Default constructor. This constructor is used by Lambda to construct the instance. When invoked in a Lambda environment
+        /// the AWS credentials will come from the IAM role associated with the function and the AWS region will be set to the
+        /// region the Lambda function is executed in.
+        /// </summary>
+        public ValidScheduleEvents_ProcessScheduledEventAsync_Generated()
+        {
+            SetExecutionEnvironment();
+            validScheduleEvents = new ValidScheduleEvents();
+            serializer = new Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer();
+        }
+
+        /// <summary>
+        /// The generated Lambda function handler for <see cref="ProcessScheduledEventAsync(Amazon.Lambda.CloudWatchEvents.ScheduledEvents.ScheduledEvent)"/>
+        /// </summary>
+        /// <param name="__evnt__">The request object that will be processed by the Lambda function handler.</param>
+        /// <returns>Result of the Lambda function execution</returns>
+        public async System.Threading.Tasks.Task ProcessScheduledEventAsync(Amazon.Lambda.CloudWatchEvents.ScheduledEvents.ScheduledEvent __evnt__)
+        {
+            await validScheduleEvents.ProcessScheduledEventAsync(__evnt__);
+        }
+
+        private static void SetExecutionEnvironment()
+        {
+            const string envName = "AWS_EXECUTION_ENV";
+
+            var envValue = new StringBuilder();
+
+            // If there is an existing execution environment variable add the annotations package as a suffix.
+            if(!string.IsNullOrEmpty(Environment.GetEnvironmentVariable(envName)))
+            {
+                envValue.Append($"{Environment.GetEnvironmentVariable(envName)}_");
+            }
+
+            envValue.Append("lib/amazon-lambda-annotations#{ANNOTATIONS_ASSEMBLY_VERSION}");
+
+            Environment.SetEnvironmentVariable(envName, envValue.ToString());
+        }
+    }
+}
diff --git a/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/Snapshots/Schedule/ValidScheduleEvents_ProcessScheduledEvent_Generated.g.cs b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/Snapshots/Schedule/ValidScheduleEvents_ProcessScheduledEvent_Generated.g.cs
new file mode 100644
index 000000000..fe9d08df4
--- /dev/null
+++ b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/Snapshots/Schedule/ValidScheduleEvents_ProcessScheduledEvent_Generated.g.cs
@@ -0,0 +1,57 @@
+// <auto-generated/>
+
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using System.IO;
+using Amazon.Lambda.Core;
+
+namespace TestServerlessApp.ScheduleEventExamples
+{
+    public class ValidScheduleEvents_ProcessScheduledEvent_Generated
+    {
+        private readonly ValidScheduleEvents validScheduleEvents;
+        private readonly Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer serializer;
+
+        /// <summary>
+        /// Default constructor. This constructor is used by Lambda to construct the instance. When invoked in a Lambda environment
+        /// the AWS credentials will come from the IAM role associated with the function and the AWS region will be set to the
+        /// region the Lambda function is executed in.
+        /// </summary>
+        public ValidScheduleEvents_ProcessScheduledEvent_Generated()
+        {
+            SetExecutionEnvironment();
+            validScheduleEvents = new ValidScheduleEvents();
+            serializer = new Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer();
+        }
+
+        /// <summary>
+        /// The generated Lambda function handler for <see cref="ProcessScheduledEvent(Amazon.Lambda.CloudWatchEvents.ScheduledEvents.ScheduledEvent)"/>
+        /// </summary>
+        /// <param name="__evnt__">The request object that will be processed by the Lambda function handler.</param>
+        /// <returns>Result of the Lambda function execution</returns>
+        public void ProcessScheduledEvent(Amazon.Lambda.CloudWatchEvents.ScheduledEvents.ScheduledEvent __evnt__)
+        {
+            validScheduleEvents.ProcessScheduledEvent(__evnt__);
+        }
+
+        private static void SetExecutionEnvironment()
+        {
+            const string envName = "AWS_EXECUTION_ENV";
+
+            var envValue = new StringBuilder();
+
+            // If there is an existing execution environment variable add the annotations package as a suffix.
+            if(!string.IsNullOrEmpty(Environment.GetEnvironmentVariable(envName)))
+            {
+                envValue.Append($"{Environment.GetEnvironmentVariable(envName)}_");
+            }
+
+            envValue.Append("lib/amazon-lambda-annotations#{ANNOTATIONS_ASSEMBLY_VERSION}");
+
+            Environment.SetEnvironmentVariable(envName, envValue.ToString());
+        }
+    }
+}
diff --git a/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/Snapshots/ServerlessTemplates/scheduleEvents.template b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/Snapshots/ServerlessTemplates/scheduleEvents.template
new file mode 100644
index 000000000..0584bd007
--- /dev/null
+++ b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/Snapshots/ServerlessTemplates/scheduleEvents.template
@@ -0,0 +1,83 @@
+{
+  "AWSTemplateFormatVersion": "2010-09-09",
+  "Transform": "AWS::Serverless-2016-10-31",
+  "Description": "This template is partially managed by Amazon.Lambda.Annotations (v{ANNOTATIONS_ASSEMBLY_VERSION}).",
+  "Resources": {
+    "TestServerlessAppScheduleEventExamplesValidScheduleEventsProcessScheduledEventGenerated": {
+      "Type": "AWS::Serverless::Function",
+      "Metadata": {
+        "Tool": "Amazon.Lambda.Annotations",
+        "SyncedEvents": [
+          "rate5minutes"
+        ],
+        "SyncedEventProperties": {
+          "rate5minutes": [
+            "Schedule",
+            "Description",
+            "Input"
+          ]
+        }
+      },
+      "Properties": {
+        "MemorySize": 512,
+        "Timeout": 30,
+        "Policies": [
+          "AWSLambdaBasicExecutionRole"
+        ],
+        "PackageType": "Image",
+        "ImageUri": ".",
+        "ImageConfig": {
+          "Command": [
+            "TestProject::TestServerlessApp.ScheduleEventExamples.ValidScheduleEvents_ProcessScheduledEvent_Generated::ProcessScheduledEvent"
+          ]
+        },
+        "Events": {
+          "rate5minutes": {
+            "Type": "Schedule",
+            "Properties": {
+              "Schedule": "rate(5 minutes)",
+              "Description": "Runs every 5 minutes",
+              "Input": "{ \"key\": \"value\" }"
+            }
+          }
+        }
+      }
+    },
+    "TestServerlessAppScheduleEventExamplesValidScheduleEventsProcessScheduledEventAsyncGenerated": {
+      "Type": "AWS::Serverless::Function",
+      "Metadata": {
+        "Tool": "Amazon.Lambda.Annotations",
+        "SyncedEvents": [
+          "DailyNoonSchedule"
+        ],
+        "SyncedEventProperties": {
+          "DailyNoonSchedule": [
+            "Schedule"
+          ]
+        }
+      },
+      "Properties": {
+        "MemorySize": 512,
+        "Timeout": 30,
+        "Policies": [
+          "AWSLambdaBasicExecutionRole"
+        ],
+        "PackageType": "Image",
+        "ImageUri": ".",
+        "ImageConfig": {
+          "Command": [
+            "TestProject::TestServerlessApp.ScheduleEventExamples.ValidScheduleEvents_ProcessScheduledEventAsync_Generated::ProcessScheduledEventAsync"
+          ]
+        },
+        "Events": {
+          "DailyNoonSchedule": {
+            "Type": "Schedule",
+            "Properties": {
+              "Schedule": "cron(0 12 * * ? *)"
+            }
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/SourceGeneratorTests.cs b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/SourceGeneratorTests.cs
index d14bb893f..2c8d8a030 100644
--- a/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/SourceGeneratorTests.cs
+++ b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/SourceGeneratorTests.cs
@@ -1388,6 +1388,53 @@ public async Task VerifyValidALBEvents()
             }.RunAsync();
         }
 
+        [Fact]
+        public async Task VerifyValidScheduleEvents()
+        {
+            var expectedTemplateContent = await ReadSnapshotContent(Path.Combine("Snapshots", "ServerlessTemplates", "scheduleEvents.template"));
+            var validScheduleEventsProcessScheduledEventGeneratedContent = await ReadSnapshotContent(Path.Combine("Snapshots", "Schedule", "ValidScheduleEvents_ProcessScheduledEvent_Generated.g.cs"));
+            var validScheduleEventsProcessScheduledEventAsyncGeneratedContent = await ReadSnapshotContent(Path.Combine("Snapshots", "Schedule", "ValidScheduleEvents_ProcessScheduledEventAsync_Generated.g.cs"));
+
+            await new VerifyCS.Test
+            {
+                TestState =
+                {
+                    Sources =
+                    {
+                        (Path.Combine("TestServerlessApp", "PlaceholderClass.cs"), await File.ReadAllTextAsync(Path.Combine("TestServerlessApp", "PlaceholderClass.cs"))),
+                        (Path.Combine("TestServerlessApp", "ScheduleEventExamples", "ValidScheduleEvents.cs"), await File.ReadAllTextAsync(Path.Combine("TestServerlessApp", "ScheduleEventExamples", "ValidScheduleEvents.cs.txt"))),
+                        (Path.Combine("Amazon.Lambda.Annotations", "LambdaFunctionAttribute.cs"), await File.ReadAllTextAsync(Path.Combine("Amazon.Lambda.Annotations", "LambdaFunctionAttribute.cs"))),
+                        (Path.Combine("Amazon.Lambda.Annotations", "Schedule", "ScheduleEventAttribute.cs"), await File.ReadAllTextAsync(Path.Combine("Amazon.Lambda.Annotations", "Schedule", "ScheduleEventAttribute.cs"))),
+                        (Path.Combine("TestServerlessApp", "AssemblyAttributes.cs"), await File.ReadAllTextAsync(Path.Combine("TestServerlessApp", "AssemblyAttributes.cs"))),
+                    },
+                    GeneratedSources =
+                    {
+                        (
+                            typeof(SourceGenerator.Generator),
+                            "ValidScheduleEvents_ProcessScheduledEvent_Generated.g.cs",
+                            SourceText.From(validScheduleEventsProcessScheduledEventGeneratedContent, Encoding.UTF8, SourceHashAlgorithm.Sha256)
+                        ),
+                        (
+                            typeof(SourceGenerator.Generator),
+                            "ValidScheduleEvents_ProcessScheduledEventAsync_Generated.g.cs",
+                            SourceText.From(validScheduleEventsProcessScheduledEventAsyncGeneratedContent, Encoding.UTF8, SourceHashAlgorithm.Sha256)
+                        )
+                    },
+                    ExpectedDiagnostics =
+                    {
+                        new DiagnosticResult("AWSLambda0103", DiagnosticSeverity.Info)
+                        .WithArguments("ValidScheduleEvents_ProcessScheduledEvent_Generated.g.cs", validScheduleEventsProcessScheduledEventGeneratedContent),
+
+                        new DiagnosticResult("AWSLambda0103", DiagnosticSeverity.Info)
+                        .WithArguments("ValidScheduleEvents_ProcessScheduledEventAsync_Generated.g.cs", validScheduleEventsProcessScheduledEventAsyncGeneratedContent),
+
+                        new DiagnosticResult("AWSLambda0103", DiagnosticSeverity.Info)
+                        .WithArguments($"TestServerlessApp{Path.DirectorySeparatorChar}serverless.template", expectedTemplateContent)
+                    }
+                }
+            }.RunAsync();
+        }
+
         [Fact]
         public async Task ExceededMaximumHandlerLength()
         {
diff --git a/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/WriterTests/ScheduleEventsTests.cs b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/WriterTests/ScheduleEventsTests.cs
new file mode 100644
index 000000000..cb93f9929
--- /dev/null
+++ b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/WriterTests/ScheduleEventsTests.cs
@@ -0,0 +1,141 @@
+using Amazon.Lambda.Annotations.SourceGenerator;
+using Amazon.Lambda.Annotations.SourceGenerator.Models;
+using Amazon.Lambda.Annotations.SourceGenerator.Models.Attributes;
+using Amazon.Lambda.Annotations.SourceGenerator.Writers;
+using Amazon.Lambda.Annotations.Schedule;
+using System.Collections.Generic;
+using Xunit;
+
+namespace Amazon.Lambda.Annotations.SourceGenerators.Tests.WriterTests
+{
+    public partial class CloudFormationWriterTests
+    {
+        [Theory]
+        [InlineData(CloudFormationTemplateFormat.Json)]
+        [InlineData(CloudFormationTemplateFormat.Yaml)]
+        public void VerifyScheduleEventAttributes_AreCorrectlyApplied(CloudFormationTemplateFormat templateFormat)
+        {
+            // ARRANGE
+            var mockFileManager = GetMockFileManager(string.Empty);
+            var lambdaFunctionModel = GetLambdaFunctionModel();
+            lambdaFunctionModel.PackageType = LambdaPackageType.Zip;
+
+            var att = new ScheduleEventAttribute("rate(5 minutes)")
+            {
+                ResourceName = "MySchedule",
+                Description = "Process every 5 minutes",
+                Input = "{\"key\": \"value\"}",
+                Enabled = true
+            };
+            lambdaFunctionModel.Attributes.Add(new AttributeModel<ScheduleEventAttribute> { Data = att });
+            var cloudFormationWriter = GetCloudFormationWriter(mockFileManager, _directoryManager, templateFormat, _diagnosticReporter);
+            var report = GetAnnotationReport([lambdaFunctionModel]);
+
+            // ACT
+            cloudFormationWriter.ApplyReport(report);
+
+            // ASSERT
+            ITemplateWriter templateWriter = templateFormat == CloudFormationTemplateFormat.Json ? new JsonWriter() : new YamlWriter();
+            templateWriter.Parse(mockFileManager.ReadAllText(ServerlessTemplateFilePath));
+
+            var eventPath = $"Resources.{lambdaFunctionModel.ResourceName}.Properties.Events.MySchedule";
+            var eventPropertiesPath = $"{eventPath}.Properties";
+
+            Assert.True(templateWriter.Exists(eventPath));
+            Assert.Equal("Schedule", templateWriter.GetToken<string>($"{eventPath}.Type"));
+            Assert.Equal("rate(5 minutes)", templateWriter.GetToken<string>($"{eventPropertiesPath}.Schedule"));
+            Assert.Equal("Process every 5 minutes", templateWriter.GetToken<string>($"{eventPropertiesPath}.Description"));
+            Assert.Equal("{\"key\": \"value\"}", templateWriter.GetToken<string>($"{eventPropertiesPath}.Input"));
+            Assert.Equal(true, templateWriter.GetToken<bool>($"{eventPropertiesPath}.Enabled"));
+        }
+
+        [Theory]
+        [InlineData(CloudFormationTemplateFormat.Json)]
+        [InlineData(CloudFormationTemplateFormat.Yaml)]
+        public void VerifyScheduleEventProperties_AreSyncedCorrectly(CloudFormationTemplateFormat templateFormat)
+        {
+            // ARRANGE
+            var mockFileManager = GetMockFileManager(string.Empty);
+            var lambdaFunctionModel = GetLambdaFunctionModel();
+            lambdaFunctionModel.PackageType = LambdaPackageType.Zip;
+            var eventResourceName = "MySchedule";
+            var eventPropertiesPath = $"Resources.{lambdaFunctionModel.ResourceName}.Properties.Events.{eventResourceName}.Properties";
+            var syncedEventPropertiesPath = $"Resources.{lambdaFunctionModel.ResourceName}.Metadata.SyncedEventProperties";
+
+            var initialAttribute = new ScheduleEventAttribute("rate(5 minutes)")
+            {
+                ResourceName = eventResourceName,
+                Description = "Every 5 minutes"
+            };
+            lambdaFunctionModel.Attributes = [new AttributeModel<ScheduleEventAttribute> { Data = initialAttribute }];
+            var cloudFormationWriter = GetCloudFormationWriter(mockFileManager, _directoryManager, templateFormat, _diagnosticReporter);
+            var report = GetAnnotationReport([lambdaFunctionModel]);
+
+            // ACT
+            cloudFormationWriter.ApplyReport(report);
+
+            // ASSERT
+            ITemplateWriter templateWriter = templateFormat == CloudFormationTemplateFormat.Json ? new JsonWriter() : new YamlWriter();
+            templateWriter.Parse(mockFileManager.ReadAllText(ServerlessTemplateFilePath));
+
+            Assert.Equal("rate(5 minutes)", templateWriter.GetToken<string>($"{eventPropertiesPath}.Schedule"));
+            Assert.Equal("Every 5 minutes", templateWriter.GetToken<string>($"{eventPropertiesPath}.Description"));
+            Assert.False(templateWriter.Exists($"{eventPropertiesPath}.Input"));
+            Assert.False(templateWriter.Exists($"{eventPropertiesPath}.Enabled"));
+
+            var syncedEventProperties = templateWriter.GetToken<Dictionary<string, List<string>>>($"{syncedEventPropertiesPath}");
+            Assert.Equal(2, syncedEventProperties[eventResourceName].Count);
+            Assert.Contains("Schedule", syncedEventProperties[eventResourceName]);
+            Assert.Contains("Description", syncedEventProperties[eventResourceName]);
+
+            // Update to cron with Input
+            var updatedAttribute = new ScheduleEventAttribute("cron(0 12 * * ? *)")
+            {
+                ResourceName = eventResourceName,
+                Input = "{\"type\": \"daily\"}"
+            };
+            lambdaFunctionModel.Attributes = [new AttributeModel<ScheduleEventAttribute> { Data = updatedAttribute }];
+            report = GetAnnotationReport([lambdaFunctionModel]);
+            cloudFormationWriter.ApplyReport(report);
+
+            templateWriter.Parse(mockFileManager.ReadAllText(ServerlessTemplateFilePath));
+            Assert.Equal("cron(0 12 * * ? *)", templateWriter.GetToken<string>($"{eventPropertiesPath}.Schedule"));
+            Assert.Equal("{\"type\": \"daily\"}", templateWriter.GetToken<string>($"{eventPropertiesPath}.Input"));
+            Assert.False(templateWriter.Exists($"{eventPropertiesPath}.Description"));
+
+            syncedEventProperties = templateWriter.GetToken<Dictionary<string, List<string>>>($"{syncedEventPropertiesPath}");
+            Assert.Equal(2, syncedEventProperties[eventResourceName].Count);
+            Assert.Contains("Schedule", syncedEventProperties[eventResourceName]);
+            Assert.Contains("Input", syncedEventProperties[eventResourceName]);
+        }
+
+        [Theory]
+        [InlineData(CloudFormationTemplateFormat.Json)]
+        [InlineData(CloudFormationTemplateFormat.Yaml)]
+        public void VerifyScheduleEvent_MinimalAttributes(CloudFormationTemplateFormat templateFormat)
+        {
+            // ARRANGE
+            var mockFileManager = GetMockFileManager(string.Empty);
+            var lambdaFunctionModel = GetLambdaFunctionModel();
+            lambdaFunctionModel.PackageType = LambdaPackageType.Zip;
+
+            var att = new ScheduleEventAttribute("rate(1 hour)") { ResourceName = "HourlySchedule" };
+            lambdaFunctionModel.Attributes.Add(new AttributeModel<ScheduleEventAttribute> { Data = att });
+            var cloudFormationWriter = GetCloudFormationWriter(mockFileManager, _directoryManager, templateFormat, _diagnosticReporter);
+            var report = GetAnnotationReport([lambdaFunctionModel]);
+
+            // ACT
+            cloudFormationWriter.ApplyReport(report);
+
+            // ASSERT
+            ITemplateWriter templateWriter = templateFormat == CloudFormationTemplateFormat.Json ? new JsonWriter() : new YamlWriter();
+            templateWriter.Parse(mockFileManager.ReadAllText(ServerlessTemplateFilePath));
+
+            var eventPropertiesPath = $"Resources.{lambdaFunctionModel.ResourceName}.Properties.Events.HourlySchedule.Properties";
+            Assert.Equal("rate(1 hour)", templateWriter.GetToken<string>($"{eventPropertiesPath}.Schedule"));
+            Assert.False(templateWriter.Exists($"{eventPropertiesPath}.Description"));
+            Assert.False(templateWriter.Exists($"{eventPropertiesPath}.Input"));
+            Assert.False(templateWriter.Exists($"{eventPropertiesPath}.Enabled"));
+        }
+    }
+}
diff --git a/Libraries/test/TestServerlessApp.IntegrationTests/IntegrationTestContextFixture.cs b/Libraries/test/TestServerlessApp.IntegrationTests/IntegrationTestContextFixture.cs
index 0102424a8..1e3de3ab6 100644
--- a/Libraries/test/TestServerlessApp.IntegrationTests/IntegrationTestContextFixture.cs
+++ b/Libraries/test/TestServerlessApp.IntegrationTests/IntegrationTestContextFixture.cs
@@ -90,7 +90,7 @@ public async Task InitializeAsync()
             Console.WriteLine($"[IntegrationTest] Found {LambdaFunctions.Count} Lambda functions: {string.Join(", ", LambdaFunctions.Select(f => f.Name ?? "(null)"))}");
 
             Assert.True(await _s3Helper.BucketExistsAsync(_bucketName), $"S3 bucket {_bucketName} should exist");
-            Assert.Equal(37, LambdaFunctions.Count);
+            Assert.Equal(38, LambdaFunctions.Count);
             Assert.False(string.IsNullOrEmpty(RestApiUrlPrefix), "RestApiUrlPrefix should not be empty");
             Assert.False(string.IsNullOrEmpty(HttpApiUrlPrefix), "HttpApiUrlPrefix should not be empty");
 
diff --git a/Libraries/test/TestServerlessApp.IntegrationTests/ScheduleEventRule.cs b/Libraries/test/TestServerlessApp.IntegrationTests/ScheduleEventRule.cs
new file mode 100644
index 000000000..49d2afad6
--- /dev/null
+++ b/Libraries/test/TestServerlessApp.IntegrationTests/ScheduleEventRule.cs
@@ -0,0 +1,38 @@
+using System.Linq;
+using System.Threading.Tasks;
+using Amazon.CloudWatchEvents;
+using Amazon.CloudWatchEvents.Model;
+using Xunit;
+
+namespace TestServerlessApp.IntegrationTests
+{
+    [Collection("Integration Tests")]
+    public class ScheduleEventRule
+    {
+        private readonly IntegrationTestContextFixture _fixture;
+
+        public ScheduleEventRule(IntegrationTestContextFixture fixture)
+        {
+            _fixture = fixture;
+        }
+
+        [Fact]
+        public async Task VerifyScheduleEventRuleConfiguration()
+        {
+            var lambdaFunctionName = _fixture.LambdaFunctions.FirstOrDefault(x => string.Equals(x.LogicalId, "ScheduledHandler"))?.Name;
+            Assert.NotNull(lambdaFunctionName);
+
+            // SAM creates EventBridge rules with names derived from the stack
+            var eventsClient = new AmazonCloudWatchEventsClient(Amazon.RegionEndpoint.USWest2);
+            var rulesResponse = await eventsClient.ListRulesAsync(new ListRulesRequest());
+
+            // Find the rule targeting our function
+            var matchingRule = rulesResponse.Rules.FirstOrDefault(r =>
+                r.Name.Contains("FiveMinuteSchedule") || r.Name.Contains("ScheduledHandler"));
+
+            Assert.NotNull(matchingRule);
+            Assert.Equal("rate(5 minutes)", matchingRule.ScheduleExpression);
+            Assert.Equal("Runs every 5 minutes", matchingRule.Description);
+        }
+    }
+}
diff --git a/Libraries/test/TestServerlessApp.IntegrationTests/TestServerlessApp.IntegrationTests.csproj b/Libraries/test/TestServerlessApp.IntegrationTests/TestServerlessApp.IntegrationTests.csproj
index 5f0728358..4f2ad5a33 100644
--- a/Libraries/test/TestServerlessApp.IntegrationTests/TestServerlessApp.IntegrationTests.csproj
+++ b/Libraries/test/TestServerlessApp.IntegrationTests/TestServerlessApp.IntegrationTests.csproj
@@ -8,6 +8,7 @@
     <ItemGroup>
         <!-- AWSSDK.SecurityToken is needed at runtime for environments which uses assume-role operation for credentials -->
         <PackageReference Include="AWSSDK.SecurityToken" Version="3.7.1.99" />
+        <PackageReference Include="AWSSDK.CloudWatchEvents" Version="3.7.*" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
         <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
         <PackageReference Include="xunit" Version="2.4.1" />
diff --git a/Libraries/test/TestServerlessApp/ScheduleEventExamples/ValidScheduleEvents.cs.txt b/Libraries/test/TestServerlessApp/ScheduleEventExamples/ValidScheduleEvents.cs.txt
new file mode 100644
index 000000000..179417209
--- /dev/null
+++ b/Libraries/test/TestServerlessApp/ScheduleEventExamples/ValidScheduleEvents.cs.txt
@@ -0,0 +1,28 @@
+using Amazon.Lambda.Annotations;
+using Amazon.Lambda.Annotations.Schedule;
+using Amazon.Lambda.CloudWatchEvents.ScheduledEvents;
+using System;
+using System.Threading.Tasks;
+
+namespace TestServerlessApp.ScheduleEventExamples
+{
+    // This file represents valid usage of the ScheduleEventAttribute. This is added as .txt file since we do not want to deploy these functions during our integration tests.
+    // This file is only sent as input to the source generator unit tests.
+
+    public class ValidScheduleEvents
+    {
+        [LambdaFunction(PackageType = LambdaPackageType.Image)]
+        [ScheduleEvent("rate(5 minutes)", Description = "Runs every 5 minutes", Input = "{ \"key\": \"value\" }")]
+        public void ProcessScheduledEvent(ScheduledEvent evnt)
+        {
+            Console.WriteLine($"Event processed: {evnt}");
+        }
+
+        [LambdaFunction(PackageType = LambdaPackageType.Image)]
+        [ScheduleEvent("cron(0 12 * * ? *)", ResourceName = "DailyNoonSchedule")]
+        public async Task ProcessScheduledEventAsync(ScheduledEvent evnt)
+        {
+            await Console.Out.WriteLineAsync($"Event processed: {evnt}");
+        }
+    }
+}
diff --git a/Libraries/test/TestServerlessApp/ScheduledProcessing.cs b/Libraries/test/TestServerlessApp/ScheduledProcessing.cs
new file mode 100644
index 000000000..9cd5d43d2
--- /dev/null
+++ b/Libraries/test/TestServerlessApp/ScheduledProcessing.cs
@@ -0,0 +1,17 @@
+using Amazon.Lambda.Annotations;
+using Amazon.Lambda.Annotations.Schedule;
+using Amazon.Lambda.CloudWatchEvents.ScheduledEvents;
+using Amazon.Lambda.Core;
+
+namespace TestServerlessApp
+{
+    public class ScheduledProcessing
+    {
+        [LambdaFunction(ResourceName = "ScheduledHandler", Policies = "AWSLambdaBasicExecutionRole")]
+        [ScheduleEvent("rate(5 minutes)", ResourceName = "FiveMinuteSchedule", Description = "Runs every 5 minutes")]
+        public void HandleSchedule(ScheduledEvent evnt, ILambdaContext lambdaContext)
+        {
+            lambdaContext.Logger.Log($"Scheduled event received at {evnt.Time}");
+        }
+    }
+}
diff --git a/Libraries/test/TestServerlessApp/TestServerlessApp.csproj b/Libraries/test/TestServerlessApp/TestServerlessApp.csproj
index 83d7cf89e..b7ef315c1 100644
--- a/Libraries/test/TestServerlessApp/TestServerlessApp.csproj
+++ b/Libraries/test/TestServerlessApp/TestServerlessApp.csproj
@@ -27,6 +27,7 @@
     <ProjectReference Include="..\..\src\Amazon.Lambda.Annotations\Amazon.Lambda.Annotations.csproj" />
     <ProjectReference Include="..\..\src\Amazon.Lambda.APIGatewayEvents\Amazon.Lambda.APIGatewayEvents.csproj" />
     <ProjectReference Include="..\..\src\Amazon.Lambda.SQSEvents\Amazon.Lambda.SQSEvents.csproj" />
+    <ProjectReference Include="..\..\src\Amazon.Lambda.CloudWatchEvents\Amazon.Lambda.CloudWatchEvents.csproj" />
     <ProjectReference Include="..\..\src\Amazon.Lambda.S3Events\Amazon.Lambda.S3Events.csproj" />
     <ProjectReference Include="..\..\src\Amazon.Lambda.Core\Amazon.Lambda.Core.csproj" />
     <ProjectReference Include="..\..\src\Amazon.Lambda.Serialization.SystemTextJson\Amazon.Lambda.Serialization.SystemTextJson.csproj" />