diff --git a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Diagnostics/DiagnosticDescriptors.cs b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Diagnostics/DiagnosticDescriptors.cs
index 69c4f9428..728f649fe 100644
--- a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Diagnostics/DiagnosticDescriptors.cs
+++ b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Diagnostics/DiagnosticDescriptors.cs
@@ -242,5 +242,12 @@ public static class DiagnosticDescriptors
             category: "AWSLambdaCSharpGenerator",
             DiagnosticSeverity.Error,
             isEnabledByDefault: true);
+
+        public static readonly DiagnosticDescriptor InvalidDynamoDBEventAttribute = new DiagnosticDescriptor(id: "AWSLambda0132",
+            title: "Invalid DynamoDBEventAttribute",
+            messageFormat: "Invalid DynamoDBEventAttribute 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 328a29ac5..f9cd13657 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.APIGateway;
+using Amazon.Lambda.Annotations.DynamoDB;
 using Amazon.Lambda.Annotations.SQS;
 using Microsoft.CodeAnalysis;
 
@@ -90,6 +91,15 @@ public static AttributeModel Build(AttributeData att, GeneratorExecutionContext
                     Type = TypeModelBuilder.Build(att.AttributeClass, context)
                 };
             }
+            else if (att.AttributeClass.Equals(context.Compilation.GetTypeByMetadataName(TypeFullNames.DynamoDBEventAttribute), SymbolEqualityComparer.Default))
+            {
+                var data = DynamoDBEventAttributeBuilder.Build(att);
+                model = new AttributeModel<DynamoDBEventAttribute>
+                {
+                    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/DynamoDBEventAttributeBuilder.cs b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Models/Attributes/DynamoDBEventAttributeBuilder.cs
new file mode 100644
index 000000000..ae3affa94
--- /dev/null
+++ b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Models/Attributes/DynamoDBEventAttributeBuilder.cs
@@ -0,0 +1,52 @@
+using Amazon.Lambda.Annotations.DynamoDB;
+using Microsoft.CodeAnalysis;
+using System;
+
+namespace Amazon.Lambda.Annotations.SourceGenerator.Models.Attributes
+{
+    /// <summary>
+    /// Builder for <see cref="DynamoDBEventAttribute"/>.
+    /// </summary>
+    public class DynamoDBEventAttributeBuilder
+    {
+        public static DynamoDBEventAttribute Build(AttributeData att)
+        {
+            if (att.ConstructorArguments.Length != 1)
+            {
+                throw new NotSupportedException($"{TypeFullNames.DynamoDBEventAttribute} must have constructor with 1 argument.");
+            }
+            var stream = att.ConstructorArguments[0].Value as string;
+            var data = new DynamoDBEventAttribute(stream);
+
+            foreach (var pair in att.NamedArguments)
+            {
+                if (pair.Key == nameof(data.ResourceName) && pair.Value.Value is string resourceName)
+                {
+                    data.ResourceName = resourceName;
+                }
+                if (pair.Key == nameof(data.BatchSize) && pair.Value.Value is uint batchSize)
+                {
+                    data.BatchSize = batchSize;
+                }
+                else if (pair.Key == nameof(data.StartingPosition) && pair.Value.Value is string startingPosition)
+                {
+                    data.StartingPosition = startingPosition;
+                }
+                else if (pair.Key == nameof(data.Enabled) && pair.Value.Value is bool enabled)
+                {
+                    data.Enabled = enabled;
+                }
+                else if (pair.Key == nameof(data.MaximumBatchingWindowInSeconds) && pair.Value.Value is uint maximumBatchingWindowInSeconds)
+                {
+                    data.MaximumBatchingWindowInSeconds = maximumBatchingWindowInSeconds;
+                }
+                else if (pair.Key == nameof(data.Filters) && pair.Value.Value is string filters)
+                {
+                    data.Filters = filters;
+                }
+            }
+
+            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 3f5775851..205a12fd0 100644
--- a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Models/EventTypeBuilder.cs
+++ b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Models/EventTypeBuilder.cs
@@ -26,6 +26,10 @@ public static HashSet<EventType> Build(IMethodSymbol lambdaMethodSymbol,
                 {
                     events.Add(EventType.SQS);
                 }
+                else if (attribute.AttributeClass.ToDisplayString() == TypeFullNames.DynamoDBEventAttribute)
+                {
+                    events.Add(EventType.DynamoDB);
+                }
                 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 a5d7ce9ab..3d831cecb 100644
--- a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/SyntaxReceiver.cs
+++ b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/SyntaxReceiver.cs
@@ -21,7 +21,8 @@ internal class SyntaxReceiver : ISyntaxContextReceiver
             { "RestApiAuthorizerAttribute", "RestApiAuthorizer" },
             { "HttpApiAttribute", "HttpApi" },
             { "RestApiAttribute", "RestApi" },
-            { "SQSEventAttribute", "SQSEvent" }
+            { "SQSEventAttribute", "SQSEvent" },
+            { "DynamoDBEventAttribute", "DynamoDBEvent" }
         };
 
         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 6e15c2175..088e5a4f4 100644
--- a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/TypeFullNames.cs
+++ b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/TypeFullNames.cs
@@ -46,6 +46,9 @@ public static class TypeFullNames
         public const string SQSBatchResponse = "Amazon.Lambda.SQSEvents.SQSBatchResponse";
         public const string SQSEventAttribute = "Amazon.Lambda.Annotations.SQS.SQSEventAttribute";
 
+        public const string DynamoDBEvent = "Amazon.Lambda.DynamoDBEvents.DynamoDBEvent";
+        public const string DynamoDBEventAttribute = "Amazon.Lambda.Annotations.DynamoDB.DynamoDBEventAttribute";
+
         public const string LambdaSerializerAttribute = "Amazon.Lambda.Core.LambdaSerializerAttribute";
         public const string DefaultLambdaSerializer = "Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer";
 
@@ -67,7 +70,8 @@ public static class TypeFullNames
         {
             RestApiAttribute,
             HttpApiAttribute,
-            SQSEventAttribute
+            SQSEventAttribute,
+            DynamoDBEventAttribute
         };
     }
 }
\ 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 733124209..5c712fd58 100644
--- a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Validation/LambdaFunctionValidator.cs
+++ b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Validation/LambdaFunctionValidator.cs
@@ -2,6 +2,7 @@
 using Amazon.Lambda.Annotations.SourceGenerator.Extensions;
 using Amazon.Lambda.Annotations.SourceGenerator.Models;
 using Amazon.Lambda.Annotations.SourceGenerator.Models.Attributes;
+using Amazon.Lambda.Annotations.DynamoDB;
 using Amazon.Lambda.Annotations.SQS;
 using Microsoft.CodeAnalysis;
 using System.Collections.Generic;
@@ -59,6 +60,7 @@ internal static bool ValidateFunction(GeneratorExecutionContext context, IMethod
             // Validate Events
             ValidateApiGatewayEvents(lambdaFunctionModel, methodLocation, diagnostics);
             ValidateSqsEvents(lambdaFunctionModel, methodLocation, diagnostics);
+            ValidateDynamoDBEvents(lambdaFunctionModel, methodLocation, diagnostics);
 
             return ReportDiagnostics(diagnosticReporter, diagnostics);
         }
@@ -86,6 +88,16 @@ internal static bool ValidateDependencies(GeneratorExecutionContext context, IMe
                 }
             }
 
+            // Check for references to "Amazon.Lambda.DynamoDBEvents" if the Lambda method is annotated with DynamoDBEvent attribute.
+            if (lambdaMethodSymbol.HasAttribute(context, TypeFullNames.DynamoDBEventAttribute))
+            {
+                if (context.Compilation.ReferencedAssemblyNames.FirstOrDefault(x => x.Name == "Amazon.Lambda.DynamoDBEvents") == null)
+                {
+                    diagnosticReporter.Report(Diagnostic.Create(DiagnosticDescriptors.MissingDependencies, methodLocation, "Amazon.Lambda.DynamoDBEvents"));
+                    return false;
+                }
+            }
+
             return true;
         }
 
@@ -268,6 +280,45 @@ private static void ValidateSqsEvents(LambdaFunctionModel lambdaFunctionModel, L
             }
         }
 
+        private static void ValidateDynamoDBEvents(LambdaFunctionModel lambdaFunctionModel, Location methodLocation, List<Diagnostic> diagnostics)
+        {
+            if (!lambdaFunctionModel.LambdaMethod.Events.Contains(EventType.DynamoDB))
+            {
+                return;
+            }
+
+            // Validate DynamoDBEventAttributes
+            foreach (var att in lambdaFunctionModel.Attributes)
+            {
+                if (att.Type.FullName != TypeFullNames.DynamoDBEventAttribute)
+                    continue;
+
+                var dynamoDBEventAttribute = ((AttributeModel<DynamoDBEventAttribute>)att).Data;
+                var validationErrors = dynamoDBEventAttribute.Validate();
+                validationErrors.ForEach(errorMessage => diagnostics.Add(Diagnostic.Create(DiagnosticDescriptors.InvalidDynamoDBEventAttribute, methodLocation, errorMessage)));
+            }
+
+            // Validate method parameters - When using DynamoDBEventAttribute, the method signature must be (DynamoDBEvent evnt) or (DynamoDBEvent evnt, ILambdaContext context)
+            var parameters = lambdaFunctionModel.LambdaMethod.Parameters;
+            if (parameters.Count == 0 ||
+                parameters.Count > 2 ||
+                (parameters.Count == 1 && parameters[0].Type.FullName != TypeFullNames.DynamoDBEvent) ||
+                (parameters.Count == 2 && (parameters[0].Type.FullName != TypeFullNames.DynamoDBEvent || parameters[1].Type.FullName != TypeFullNames.ILambdaContext)))
+            {
+                var errorMessage = $"When using the {nameof(DynamoDBEventAttribute)}, the Lambda method can accept at most 2 parameters. " +
+                    $"The first parameter is required and must be of type {TypeFullNames.DynamoDBEvent}. " +
+                    $"The second parameter is optional and must be of type {TypeFullNames.ILambdaContext}.";
+                diagnostics.Add(Diagnostic.Create(DiagnosticDescriptors.InvalidLambdaMethodSignature, methodLocation, errorMessage));
+            }
+
+            // Validate method return type - When using DynamoDBEventAttribute, the return type must be either void or Task
+            if (!lambdaFunctionModel.LambdaMethod.ReturnsVoid && !lambdaFunctionModel.LambdaMethod.ReturnsVoidTask)
+            {
+                var errorMessage = $"When using the {nameof(DynamoDBEventAttribute)}, 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 a59aaf6d4..b9911b7da 100644
--- a/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Writers/CloudFormationWriter.cs
+++ b/Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Writers/CloudFormationWriter.cs
@@ -1,4 +1,5 @@
 using Amazon.Lambda.Annotations.APIGateway;
+using Amazon.Lambda.Annotations.DynamoDB;
 using Amazon.Lambda.Annotations.SourceGenerator.Diagnostics;
 using Amazon.Lambda.Annotations.SourceGenerator.FileIO;
 using Amazon.Lambda.Annotations.SourceGenerator.Models;
@@ -221,6 +222,10 @@ private void ProcessLambdaFunctionEventAttributes(ILambdaFunctionSerializable la
                         eventName = ProcessSqsAttribute(lambdaFunction, sqsAttributeModel.Data, currentSyncedEventProperties);
                         currentSyncedEvents.Add(eventName);
                         break;
+                    case AttributeModel<DynamoDBEventAttribute> dynamoDBAttributeModel:
+                        eventName = ProcessDynamoDBAttribute(lambdaFunction, dynamoDBAttributeModel.Data, currentSyncedEventProperties);
+                        currentSyncedEvents.Add(eventName);
+                        break;
                 }
             }
 
@@ -600,6 +605,68 @@ private string ProcessSqsAttribute(ILambdaFunctionSerializable lambdaFunction, S
         /// Writes all properties associated with <see cref="LambdaFunctionRoleAttribute"/> to the serverless template.
         /// </summary>
 
+        /// <summary>
+        /// Writes all properties associated with <see cref="DynamoDBEventAttribute"/> to the serverless template.
+        /// </summary>
+        private string ProcessDynamoDBAttribute(ILambdaFunctionSerializable lambdaFunction, DynamoDBEventAttribute att, Dictionary<string, List<string>> syncedEventProperties)
+        {
+            var eventName = att.ResourceName;
+            var eventPath = $"Resources.{lambdaFunction.ResourceName}.Properties.Events.{eventName}";
+
+            _templateWriter.SetToken($"{eventPath}.Type", "DynamoDB");
+
+            // Stream
+            _templateWriter.RemoveToken($"{eventPath}.Properties.Stream");
+            if (!att.Stream.StartsWith("@"))
+            {
+                SetEventProperty(syncedEventProperties, lambdaFunction.ResourceName, eventName, "Stream", att.Stream);
+            }
+            else
+            {
+                var resource = att.Stream.Substring(1);
+                if (_templateWriter.Exists($"{PARAMETERS}.{resource}"))
+                    SetEventProperty(syncedEventProperties, lambdaFunction.ResourceName, eventName, $"Stream.{REF}", resource);
+                else
+                    SetEventProperty(syncedEventProperties, lambdaFunction.ResourceName, eventName, $"Stream.{GET_ATTRIBUTE}", new List<string> { resource, "StreamArn" }, TokenType.List);
+            }
+
+            // StartingPosition
+            SetEventProperty(syncedEventProperties, lambdaFunction.ResourceName, eventName, "StartingPosition", att.StartingPosition);
+
+            // BatchSize
+            if (att.IsBatchSizeSet)
+            {
+                SetEventProperty(syncedEventProperties, lambdaFunction.ResourceName, eventName, "BatchSize", att.BatchSize);
+            }
+
+            // Enabled
+            if (att.IsEnabledSet)
+            {
+                SetEventProperty(syncedEventProperties, lambdaFunction.ResourceName, eventName, "Enabled", att.Enabled);
+            }
+
+            // MaximumBatchingWindowInSeconds
+            if (att.IsMaximumBatchingWindowInSecondsSet)
+            {
+                SetEventProperty(syncedEventProperties, lambdaFunction.ResourceName, eventName, "MaximumBatchingWindowInSeconds", att.MaximumBatchingWindowInSeconds);
+            }
+
+            // FilterCriteria
+            if (att.IsFiltersSet)
+            {
+                const char SEPERATOR = ';';
+                var filters = att.Filters.Split(SEPERATOR).Select(x => x.Trim()).ToList();
+                var filterList = new List<Dictionary<string, string>>();
+                foreach (var filter in filters)
+                {
+                    filterList.Add(new Dictionary<string, string> { { "Pattern", filter } });
+                }
+                SetEventProperty(syncedEventProperties, lambdaFunction.ResourceName, eventName, "FilterCriteria.Filters", filterList, TokenType.List);
+            }
+
+            return att.ResourceName;
+        }
+
         /// <summary>
         /// Writes the default values for the Lambda function's metadata and properties.
         /// </summary>
diff --git a/Libraries/src/Amazon.Lambda.Annotations/DynamoDB/DynamoDBEventAttribute.cs b/Libraries/src/Amazon.Lambda.Annotations/DynamoDB/DynamoDBEventAttribute.cs
new file mode 100644
index 000000000..d85c0963c
--- /dev/null
+++ b/Libraries/src/Amazon.Lambda.Annotations/DynamoDB/DynamoDBEventAttribute.cs
@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+namespace Amazon.Lambda.Annotations.DynamoDB
+{
+    /// <summary>
+    /// This attribute defines the DynamoDB event source configuration for a Lambda function.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
+    public class DynamoDBEventAttribute : Attribute
+    {
+        private static readonly Regex _resourceNameRegex = new Regex("^[a-zA-Z0-9]+$");
+
+        /// <summary>
+        /// The DynamoDB stream that will act as the event trigger for the Lambda function.
+        /// This can either be the stream ARN or reference to the DynamoDB table resource that is already defined in the serverless template.
+        /// To reference a DynamoDB table resource in the serverless template, prefix the resource name with "@" symbol.
+        /// </summary>
+        public string Stream { get; set; }
+
+        /// <summary>
+        /// The CloudFormation resource name for the DynamoDB event source mapping.
+        /// </summary>
+        public string ResourceName
+        {
+            get
+            {
+                if (IsResourceNameSet)
+                {
+                    return resourceName;
+                }
+                if (Stream.StartsWith("@"))
+                {
+                    return Stream.Substring(1);
+                }
+
+                // DynamoDB stream ARN format: arn:aws:dynamodb:region:account:table/TableName/stream/timestamp
+                var arnParts = Stream.Split('/');
+                if (arnParts.Length >= 2)
+                {
+                    var tableName = arnParts[1];
+                    return string.Join(string.Empty, tableName.Where(char.IsLetterOrDigit));
+                }
+                return string.Join(string.Empty, Stream.Where(char.IsLetterOrDigit));
+            }
+            set => resourceName = value;
+        }
+
+        private string resourceName { get; set; } = null;
+        internal bool IsResourceNameSet => resourceName != null;
+
+        /// <summary>
+        /// The maximum number of records in each batch that Lambda pulls from the stream.
+        /// Default value is 100.
+        /// </summary>
+        public uint BatchSize
+        {
+            get => batchSize.GetValueOrDefault();
+            set => batchSize = value;
+        }
+        private uint? batchSize { get; set; }
+        internal bool IsBatchSizeSet => batchSize.HasValue;
+
+        /// <summary>
+        /// The position in the stream where Lambda starts reading. Valid values are TRIM_HORIZON and LATEST.
+        /// Default value is LATEST.
+        /// </summary>
+        public string StartingPosition { get; set; } = "LATEST";
+        internal bool IsStartingPositionSet => true;
+
+        /// <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>
+        /// The maximum amount of time, in seconds, to gather records before invoking the function.
+        /// </summary>
+        public uint MaximumBatchingWindowInSeconds
+        {
+            get => maximumBatchingWindowInSeconds.GetValueOrDefault();
+            set => maximumBatchingWindowInSeconds = value;
+        }
+        private uint? maximumBatchingWindowInSeconds { get; set; }
+        internal bool IsMaximumBatchingWindowInSecondsSet => maximumBatchingWindowInSeconds.HasValue;
+
+        /// <summary>
+        /// A collection of semicolon (;) separated strings where each string denotes a filter pattern.
+        /// </summary>
+        public string Filters { get; set; } = null;
+        internal bool IsFiltersSet => Filters != null;
+
+        /// <summary>
+        /// Creates an instance of the <see cref="DynamoDBEventAttribute"/> class.
+        /// </summary>
+        /// <param name="stream"><see cref="Stream"/> property</param>
+        public DynamoDBEventAttribute(string stream)
+        {
+            Stream = stream;
+        }
+
+        internal List<string> Validate()
+        {
+            var validationErrors = new List<string>();
+
+            if (IsBatchSizeSet && (BatchSize < 1 || BatchSize > 10000))
+            {
+                validationErrors.Add($"{nameof(DynamoDBEventAttribute.BatchSize)} = {BatchSize}. It must be between 1 and 10000");
+            }
+            if (IsMaximumBatchingWindowInSecondsSet && MaximumBatchingWindowInSeconds > 300)
+            {
+                validationErrors.Add($"{nameof(DynamoDBEventAttribute.MaximumBatchingWindowInSeconds)} = {MaximumBatchingWindowInSeconds}. It must be between 0 and 300");
+            }
+            if (!string.IsNullOrEmpty(StartingPosition) && StartingPosition != "TRIM_HORIZON" && StartingPosition != "LATEST")
+            {
+                validationErrors.Add($"{nameof(DynamoDBEventAttribute.StartingPosition)} = {StartingPosition}. It must be either TRIM_HORIZON or LATEST");
+            }
+            if (!Stream.StartsWith("@"))
+            {
+                if (!Stream.Contains(":dynamodb:") && !Stream.Contains("/stream/"))
+                {
+                    validationErrors.Add($"{nameof(DynamoDBEventAttribute.Stream)} = {Stream}. The DynamoDB stream ARN is invalid");
+                }
+            }
+            if (IsResourceNameSet && !_resourceNameRegex.IsMatch(ResourceName))
+            {
+                validationErrors.Add($"{nameof(DynamoDBEventAttribute.ResourceName)} = {ResourceName}. It must only contain alphanumeric characters and must not be an empty string");
+            }
+
+            return validationErrors;
+        }
+    }
+}
diff --git a/Libraries/src/Amazon.Lambda.RuntimeSupport/Amazon.Lambda.RuntimeSupport.csproj b/Libraries/src/Amazon.Lambda.RuntimeSupport/Amazon.Lambda.RuntimeSupport.csproj
index b3bfb0488..95c92dafb 100644
--- a/Libraries/src/Amazon.Lambda.RuntimeSupport/Amazon.Lambda.RuntimeSupport.csproj
+++ b/Libraries/src/Amazon.Lambda.RuntimeSupport/Amazon.Lambda.RuntimeSupport.csproj
@@ -3,7 +3,7 @@
   <Import Project="..\..\..\buildtools\common.props" />
 
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net6.0;net8.0;net9.0;net10.0;net11.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0;net6.0;net8.0;net9.0</TargetFrameworks>
     <Version>1.14.2</Version>
     <Description>Provides a bootstrap and Lambda Runtime API Client to help you to develop custom .NET Core Lambda Runtimes.</Description>
     <AssemblyTitle>Amazon.Lambda.RuntimeSupport</AssemblyTitle>
diff --git a/Libraries/src/SnapshotRestore.Registry/SnapshotRestore.Registry.csproj b/Libraries/src/SnapshotRestore.Registry/SnapshotRestore.Registry.csproj
index 0bb3f5886..72aa0ef6b 100644
--- a/Libraries/src/SnapshotRestore.Registry/SnapshotRestore.Registry.csproj
+++ b/Libraries/src/SnapshotRestore.Registry/SnapshotRestore.Registry.csproj
@@ -3,7 +3,7 @@
   <Import Project="..\..\..\buildtools\common.props" />
 
   <PropertyGroup>
-    <TargetFrameworks>net8.0;net9.0;net10.0;net11.0</TargetFrameworks>
+    <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
     <Version>1.0.1</Version>
     <Description>Provides a Restore Hooks library to help you register before snapshot and after restore hooks.</Description>
     <AssemblyTitle>SnapshotRestore.Registry</AssemblyTitle>
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 c8cc6f306..a7a807214 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.DynamoDBEvents\Amazon.Lambda.DynamoDBEvents.csproj" />
       <!-- 
 	    We need to force using the .NET Standard 2.0 version because the source generator test framework will complain
 		about using newer versions of System.Runtime then it can handle. This is not an issue in a end user scenario.
diff --git a/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/CSharpSourceGeneratorVerifier.cs b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/CSharpSourceGeneratorVerifier.cs
index 0d45da39e..1a15e9cbb 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.DynamoDBEvents;
 using Amazon.Lambda.SQSEvents;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
@@ -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(SQSEvent).Assembly.Location))
+                            .AddMetadataReference(projectId, MetadataReference.CreateFromFile(typeof(DynamoDBEvent).Assembly.Location))
                             .AddMetadataReference(projectId, MetadataReference.CreateFromFile(typeof(IServiceCollection).Assembly.Location))
                             .AddMetadataReference(projectId, MetadataReference.CreateFromFile(typeof(ServiceProvider).Assembly.Location))
                             .AddMetadataReference(projectId, MetadataReference.CreateFromFile(typeof(RestApiAttribute).Assembly.Location))
diff --git a/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/Snapshots/DynamoDB/ValidDynamoDBEvents_ProcessMessagesAsync_Generated.g.cs b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/Snapshots/DynamoDB/ValidDynamoDBEvents_ProcessMessagesAsync_Generated.g.cs
new file mode 100644
index 000000000..986b51396
--- /dev/null
+++ b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/Snapshots/DynamoDB/ValidDynamoDBEvents_ProcessMessagesAsync_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.DynamoDBEventExamples
+{
+    public class ValidDynamoDBEvents_ProcessMessagesAsync_Generated
+    {
+        private readonly ValidDynamoDBEvents validDynamoDBEvents;
+        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 ValidDynamoDBEvents_ProcessMessagesAsync_Generated()
+        {
+            SetExecutionEnvironment();
+            validDynamoDBEvents = new ValidDynamoDBEvents();
+            serializer = new Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer();
+        }
+
+        /// <summary>
+        /// The generated Lambda function handler for <see cref="ProcessMessagesAsync(Amazon.Lambda.DynamoDBEvents.DynamoDBEvent)"/>
+        /// </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 ProcessMessagesAsync(Amazon.Lambda.DynamoDBEvents.DynamoDBEvent __evnt__)
+        {
+            await validDynamoDBEvents.ProcessMessagesAsync(__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/DynamoDB/ValidDynamoDBEvents_ProcessMessages_Generated.g.cs b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/Snapshots/DynamoDB/ValidDynamoDBEvents_ProcessMessages_Generated.g.cs
new file mode 100644
index 000000000..814090041
--- /dev/null
+++ b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/Snapshots/DynamoDB/ValidDynamoDBEvents_ProcessMessages_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.DynamoDBEventExamples
+{
+    public class ValidDynamoDBEvents_ProcessMessages_Generated
+    {
+        private readonly ValidDynamoDBEvents validDynamoDBEvents;
+        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 ValidDynamoDBEvents_ProcessMessages_Generated()
+        {
+            SetExecutionEnvironment();
+            validDynamoDBEvents = new ValidDynamoDBEvents();
+            serializer = new Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer();
+        }
+
+        /// <summary>
+        /// The generated Lambda function handler for <see cref="ProcessMessages(Amazon.Lambda.DynamoDBEvents.DynamoDBEvent)"/>
+        /// </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 ProcessMessages(Amazon.Lambda.DynamoDBEvents.DynamoDBEvent __evnt__)
+        {
+            validDynamoDBEvents.ProcessMessages(__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/dynamoDBEvents.template b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/Snapshots/ServerlessTemplates/dynamoDBEvents.template
new file mode 100644
index 000000000..5fbcf8d48
--- /dev/null
+++ b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/Snapshots/ServerlessTemplates/dynamoDBEvents.template
@@ -0,0 +1,129 @@
+{
+  "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": {
+    "TestServerlessAppDynamoDBEventExamplesValidDynamoDBEventsProcessMessagesGenerated": {
+      "Type": "AWS::Serverless::Function",
+      "Metadata": {
+        "Tool": "Amazon.Lambda.Annotations",
+        "SyncedEvents": [
+          "MyTable",
+          "MyTable2",
+          "testTableEvent"
+        ],
+        "SyncedEventProperties": {
+          "MyTable": [
+            "Stream",
+            "StartingPosition",
+            "BatchSize",
+            "MaximumBatchingWindowInSeconds",
+            "FilterCriteria.Filters"
+          ],
+          "MyTable2": [
+            "Stream",
+            "StartingPosition",
+            "Enabled"
+          ],
+          "testTableEvent": [
+            "Stream.Fn::GetAtt",
+            "StartingPosition"
+          ]
+        }
+      },
+      "Properties": {
+        "MemorySize": 512,
+        "Timeout": 30,
+        "Policies": [
+          "AWSLambdaBasicExecutionRole"
+        ],
+        "PackageType": "Image",
+        "ImageUri": ".",
+        "ImageConfig": {
+          "Command": [
+            "TestProject::TestServerlessApp.DynamoDBEventExamples.ValidDynamoDBEvents_ProcessMessages_Generated::ProcessMessages"
+          ]
+        },
+        "Events": {
+          "MyTable": {
+            "Type": "DynamoDB",
+            "Properties": {
+              "Stream": "arn:aws:dynamodb:us-east-2:444455556666:table/MyTable/stream/2024-01-01T00:00:00",
+              "StartingPosition": "LATEST",
+              "BatchSize": 50,
+              "MaximumBatchingWindowInSeconds": 2,
+              "FilterCriteria": {
+                "Filters": [
+                  {
+                    "Pattern": "My-Filter-1"
+                  },
+                  {
+                    "Pattern": "My-Filter-2"
+                  }
+                ]
+              }
+            }
+          },
+          "MyTable2": {
+            "Type": "DynamoDB",
+            "Properties": {
+              "Stream": "arn:aws:dynamodb:us-east-2:444455556666:table/MyTable2/stream/2024-01-01T00:00:00",
+              "StartingPosition": "TRIM_HORIZON",
+              "Enabled": false
+            }
+          },
+          "testTableEvent": {
+            "Type": "DynamoDB",
+            "Properties": {
+              "Stream": {
+                "Fn::GetAtt": [
+                  "testTable",
+                  "StreamArn"
+                ]
+              },
+              "StartingPosition": "LATEST"
+            }
+          }
+        }
+      }
+    },
+    "TestServerlessAppDynamoDBEventExamplesValidDynamoDBEventsProcessMessagesAsyncGenerated": {
+      "Type": "AWS::Serverless::Function",
+      "Metadata": {
+        "Tool": "Amazon.Lambda.Annotations",
+        "SyncedEvents": [
+          "MyTable"
+        ],
+        "SyncedEventProperties": {
+          "MyTable": [
+            "Stream",
+            "StartingPosition"
+          ]
+        }
+      },
+      "Properties": {
+        "MemorySize": 512,
+        "Timeout": 30,
+        "Policies": [
+          "AWSLambdaBasicExecutionRole"
+        ],
+        "PackageType": "Image",
+        "ImageUri": ".",
+        "ImageConfig": {
+          "Command": [
+            "TestProject::TestServerlessApp.DynamoDBEventExamples.ValidDynamoDBEvents_ProcessMessagesAsync_Generated::ProcessMessagesAsync"
+          ]
+        },
+        "Events": {
+          "MyTable": {
+            "Type": "DynamoDB",
+            "Properties": {
+              "Stream": "arn:aws:dynamodb:us-east-2:444455556666:table/MyTable/stream/2024-01-01T00:00:00",
+              "StartingPosition": "LATEST"
+            }
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/SourceGeneratorTests.cs b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/SourceGeneratorTests.cs
index 63e746059..0f7398bbe 100644
--- a/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/SourceGeneratorTests.cs
+++ b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/SourceGeneratorTests.cs
@@ -1339,6 +1339,53 @@ public async Task VerifyValidSQSEvents()
             }.RunAsync();
         }
 
+        [Fact]
+        public async Task VerifyValidDynamoDBEvents()
+        {
+            var expectedTemplateContent = await ReadSnapshotContent(Path.Combine("Snapshots", "ServerlessTemplates", "dynamoDBEvents.template"));
+            var validDynamoDBEventsProcessMessagesGeneratedContent = await ReadSnapshotContent(Path.Combine("Snapshots", "DynamoDB", "ValidDynamoDBEvents_ProcessMessages_Generated.g.cs"));
+            var validDynamoDBEventsProcessMessagesAsyncGeneratedContent = await ReadSnapshotContent(Path.Combine("Snapshots", "DynamoDB", "ValidDynamoDBEvents_ProcessMessagesAsync_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", "DynamoDBEventExamples", "ValidDynamoDBEvents.cs"), await File.ReadAllTextAsync(Path.Combine("TestServerlessApp", "DynamoDBEventExamples", "ValidDynamoDBEvents.cs.txt"))),
+                        (Path.Combine("Amazon.Lambda.Annotations", "LambdaFunctionAttribute.cs"), await File.ReadAllTextAsync(Path.Combine("Amazon.Lambda.Annotations", "LambdaFunctionAttribute.cs"))),
+                        (Path.Combine("Amazon.Lambda.Annotations", "DynamoDB", "DynamoDBEventAttribute.cs"), await File.ReadAllTextAsync(Path.Combine("Amazon.Lambda.Annotations", "DynamoDB", "DynamoDBEventAttribute.cs"))),
+                        (Path.Combine("TestServerlessApp", "AssemblyAttributes.cs"), await File.ReadAllTextAsync(Path.Combine("TestServerlessApp", "AssemblyAttributes.cs"))),
+                    },
+                    GeneratedSources =
+                    {
+                        (
+                            typeof(SourceGenerator.Generator),
+                            "ValidDynamoDBEvents_ProcessMessages_Generated.g.cs",
+                            SourceText.From(validDynamoDBEventsProcessMessagesGeneratedContent, Encoding.UTF8, SourceHashAlgorithm.Sha256)
+                        ),
+                        (
+                            typeof(SourceGenerator.Generator),
+                            "ValidDynamoDBEvents_ProcessMessagesAsync_Generated.g.cs",
+                            SourceText.From(validDynamoDBEventsProcessMessagesAsyncGeneratedContent, Encoding.UTF8, SourceHashAlgorithm.Sha256)
+                        )
+                    },
+                    ExpectedDiagnostics =
+                    {
+                        new DiagnosticResult("AWSLambda0103", DiagnosticSeverity.Info)
+                        .WithArguments("ValidDynamoDBEvents_ProcessMessages_Generated.g.cs", validDynamoDBEventsProcessMessagesGeneratedContent),
+
+                        new DiagnosticResult("AWSLambda0103", DiagnosticSeverity.Info)
+                        .WithArguments("ValidDynamoDBEvents_ProcessMessagesAsync_Generated.g.cs", validDynamoDBEventsProcessMessagesAsyncGeneratedContent),
+
+                        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/DynamoDBEventsTests.cs b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/WriterTests/DynamoDBEventsTests.cs
new file mode 100644
index 000000000..1696edd28
--- /dev/null
+++ b/Libraries/test/Amazon.Lambda.Annotations.SourceGenerators.Tests/WriterTests/DynamoDBEventsTests.cs
@@ -0,0 +1,234 @@
+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.DynamoDB;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace Amazon.Lambda.Annotations.SourceGenerators.Tests.WriterTests
+{
+    public partial class CloudFormationWriterTests
+    {
+        const string streamArn1 = "arn:aws:dynamodb:us-east-2:444455556666:table/MyTable/stream/2024-01-01T00:00:00";
+        const string streamArn2 = "arn:aws:dynamodb:us-east-2:444455556666:table/MyTable2/stream/2024-01-01T00:00:00";
+
+        [Theory]
+        [ClassData(typeof(DynamoDBEventsTestData))]
+        public void VerifyDynamoDBEventAttributes_AreCorrectlyApplied(CloudFormationTemplateFormat templateFormat, IEnumerable<DynamoDBEventAttribute> dynamoDBEventAttributes)
+        {
+            // ARRANGE
+            var mockFileManager = GetMockFileManager(string.Empty);
+            var lambdaFunctionModel = GetLambdaFunctionModel();
+            lambdaFunctionModel.PackageType = LambdaPackageType.Zip;
+            lambdaFunctionModel.ReturnTypeFullName = "void";
+            foreach (var att in dynamoDBEventAttributes)
+            {
+                lambdaFunctionModel.Attributes.Add(new AttributeModel<DynamoDBEventAttribute> { 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));
+
+            foreach (var att in dynamoDBEventAttributes)
+            {
+                var eventName = att.ResourceName;
+                var eventPath = $"Resources.{lambdaFunctionModel.ResourceName}.Properties.Events.{eventName}";
+                var eventPropertiesPath = $"{eventPath}.Properties";
+
+                Assert.True(templateWriter.Exists(eventPath));
+                Assert.Equal("DynamoDB", templateWriter.GetToken<string>($"{eventPath}.Type"));
+
+                if (!att.Stream.StartsWith("@"))
+                {
+                    Assert.Equal(att.Stream, templateWriter.GetToken<string>($"{eventPropertiesPath}.Stream"));
+                }
+                else
+                {
+                    Assert.Equal([att.Stream.Substring(1), "StreamArn"], templateWriter.GetToken<List<string>>($"{eventPropertiesPath}.Stream.Fn::GetAtt"));
+                }
+
+                Assert.Equal(att.StartingPosition, templateWriter.GetToken<string>($"{eventPropertiesPath}.StartingPosition"));
+
+                Assert.Equal(att.IsBatchSizeSet, templateWriter.Exists($"{eventPropertiesPath}.BatchSize"));
+                if (att.IsBatchSizeSet)
+                {
+                    Assert.Equal(att.BatchSize, templateWriter.GetToken<uint>($"{eventPropertiesPath}.BatchSize"));
+                }
+
+                Assert.Equal(att.IsEnabledSet, templateWriter.Exists($"{eventPropertiesPath}.Enabled"));
+                if (att.IsEnabledSet)
+                {
+                    Assert.Equal(att.Enabled, templateWriter.GetToken<bool>($"{eventPropertiesPath}.Enabled"));
+                }
+
+                Assert.Equal(att.IsFiltersSet, templateWriter.Exists($"{eventPropertiesPath}.FilterCriteria"));
+                if (att.IsFiltersSet)
+                {
+                    var filtersList = templateWriter.GetToken<List<Dictionary<string, string>>>($"{eventPropertiesPath}.FilterCriteria.Filters");
+                    var index = 0;
+                    foreach (var filter in att.Filters.Split(';').Select(x => x.Trim()))
+                    {
+                        Assert.Equal(filter, filtersList[index]["Pattern"]);
+                        index++;
+                    }
+                }
+
+                Assert.Equal(att.IsMaximumBatchingWindowInSecondsSet, templateWriter.Exists($"{eventPropertiesPath}.MaximumBatchingWindowInSeconds"));
+                if (att.IsMaximumBatchingWindowInSecondsSet)
+                {
+                    Assert.Equal(att.MaximumBatchingWindowInSeconds, templateWriter.GetToken<uint>($"{eventPropertiesPath}.MaximumBatchingWindowInSeconds"));
+                }
+            }
+        }
+
+        [Theory]
+        [InlineData(CloudFormationTemplateFormat.Json)]
+        [InlineData(CloudFormationTemplateFormat.Yaml)]
+        public void VerifyDynamoDBEventProperties_AreSyncedCorrectly(CloudFormationTemplateFormat templateFormat)
+        {
+            // ARRANGE
+            var mockFileManager = GetMockFileManager(string.Empty);
+            var lambdaFunctionModel = GetLambdaFunctionModel();
+            lambdaFunctionModel.PackageType = LambdaPackageType.Zip;
+            var eventResourceName = "MyDynamoDBEvent";
+            var eventPropertiesPath = $"Resources.{lambdaFunctionModel.ResourceName}.Properties.Events.{eventResourceName}.Properties";
+            var syncedEventPropertiesPath = $"Resources.{lambdaFunctionModel.ResourceName}.Metadata.SyncedEventProperties";
+
+            var initialAttribute = new DynamoDBEventAttribute(streamArn1)
+            {
+                ResourceName = eventResourceName,
+                MaximumBatchingWindowInSeconds = 15
+            };
+            lambdaFunctionModel.Attributes = [new AttributeModel<DynamoDBEventAttribute> { Data = initialAttribute }];
+            var cloudFormationWriter = GetCloudFormationWriter(mockFileManager, _directoryManager, templateFormat, _diagnosticReporter);
+            var report = GetAnnotationReport([lambdaFunctionModel]);
+
+            // ACT
+            cloudFormationWriter.ApplyReport(report);
+
+            // Assert initial properties
+            ITemplateWriter templateWriter = templateFormat == CloudFormationTemplateFormat.Json ? new JsonWriter() : new YamlWriter();
+            templateWriter.Parse(mockFileManager.ReadAllText(ServerlessTemplateFilePath));
+
+            Assert.Equal(15, templateWriter.GetToken<int>($"{eventPropertiesPath}.MaximumBatchingWindowInSeconds"));
+            Assert.Equal(streamArn1, templateWriter.GetToken<string>($"{eventPropertiesPath}.Stream"));
+            Assert.Equal("LATEST", templateWriter.GetToken<string>($"{eventPropertiesPath}.StartingPosition"));
+            Assert.False(templateWriter.Exists($"{eventPropertiesPath}.BatchSize"));
+            Assert.False(templateWriter.Exists($"{eventPropertiesPath}.Enabled"));
+            Assert.False(templateWriter.Exists($"{eventPropertiesPath}.FilterCriteria"));
+
+            var syncedEventProperties = templateWriter.GetToken<Dictionary<string, List<string>>>($"{syncedEventPropertiesPath}");
+            Assert.Equal(3, syncedEventProperties[eventResourceName].Count);
+            Assert.Contains("Stream", syncedEventProperties[eventResourceName]);
+            Assert.Contains("StartingPosition", syncedEventProperties[eventResourceName]);
+            Assert.Contains("MaximumBatchingWindowInSeconds", syncedEventProperties[eventResourceName]);
+
+            // Update attribute
+            var updatedAttribute = new DynamoDBEventAttribute(streamArn2)
+            {
+                ResourceName = eventResourceName,
+                BatchSize = 10
+            };
+            lambdaFunctionModel.Attributes = [new AttributeModel<DynamoDBEventAttribute> { Data = updatedAttribute }];
+            report = GetAnnotationReport([lambdaFunctionModel]);
+            cloudFormationWriter.ApplyReport(report);
+
+            templateWriter.Parse(mockFileManager.ReadAllText(ServerlessTemplateFilePath));
+            Assert.Equal(10, templateWriter.GetToken<int>($"{eventPropertiesPath}.BatchSize"));
+            Assert.Equal(streamArn2, templateWriter.GetToken<string>($"{eventPropertiesPath}.Stream"));
+            Assert.Equal("LATEST", templateWriter.GetToken<string>($"{eventPropertiesPath}.StartingPosition"));
+            Assert.False(templateWriter.Exists($"{eventPropertiesPath}.MaximumBatchingWindowInSeconds"));
+            Assert.False(templateWriter.Exists($"{eventPropertiesPath}.Enabled"));
+
+            syncedEventProperties = templateWriter.GetToken<Dictionary<string, List<string>>>($"{syncedEventPropertiesPath}");
+            Assert.Equal(3, syncedEventProperties[eventResourceName].Count);
+            Assert.Contains("BatchSize", syncedEventProperties[eventResourceName]);
+            Assert.Contains("Stream", syncedEventProperties[eventResourceName]);
+            Assert.Contains("StartingPosition", syncedEventProperties[eventResourceName]);
+        }
+
+        [Theory]
+        [InlineData(CloudFormationTemplateFormat.Json)]
+        [InlineData(CloudFormationTemplateFormat.Yaml)]
+        public void SwitchBetweenArnAndRef_ForDynamoDBStream(CloudFormationTemplateFormat templateFormat)
+        {
+            // Arrange
+            ITemplateWriter templateWriter = templateFormat == CloudFormationTemplateFormat.Json ? new JsonWriter() : new YamlWriter();
+            var mockFileManager = GetMockFileManager(string.Empty);
+            var cloudFormationWriter = GetCloudFormationWriter(mockFileManager, _directoryManager, templateFormat, _diagnosticReporter);
+
+            var lambdaFunctionModel = GetLambdaFunctionModel();
+            var eventResourceName = "MyDynamoDBEvent";
+
+            var syncedEventPropertiesPath = $"Resources.{lambdaFunctionModel.ResourceName}.Metadata.SyncedEventProperties";
+            var eventPropertiesPath = $"Resources.{lambdaFunctionModel.ResourceName}.Properties.Events.{eventResourceName}.Properties";
+
+            // Start with Stream ARN
+            var dynamoDBEventAttribute = new DynamoDBEventAttribute(streamArn1) { ResourceName = eventResourceName };
+            lambdaFunctionModel.Attributes = [new AttributeModel<DynamoDBEventAttribute> { Data = dynamoDBEventAttribute }];
+
+            // Act
+            var report = GetAnnotationReport([lambdaFunctionModel]);
+            cloudFormationWriter.ApplyReport(report);
+
+            // Assert - Stream as ARN
+            templateWriter.Parse(mockFileManager.ReadAllText(ServerlessTemplateFilePath));
+            var syncedEventProperties = templateWriter.GetToken<Dictionary<string, List<string>>>($"{syncedEventPropertiesPath}");
+
+            Assert.Equal(streamArn1, templateWriter.GetToken<string>($"{eventPropertiesPath}.Stream"));
+            Assert.False(templateWriter.Exists($"{eventPropertiesPath}.Stream.Fn::GetAtt"));
+            Assert.Contains("Stream", syncedEventProperties[eventResourceName]);
+
+            // Switch to Stream reference
+            dynamoDBEventAttribute.Stream = "@MyTable";
+            cloudFormationWriter.ApplyReport(report);
+
+            // Assert - Stream as Ref
+            templateWriter.Parse(mockFileManager.ReadAllText(ServerlessTemplateFilePath));
+            syncedEventProperties = templateWriter.GetToken<Dictionary<string, List<string>>>($"{syncedEventPropertiesPath}");
+
+            Assert.Equal(["MyTable", "StreamArn"], templateWriter.GetToken<List<string>>($"{eventPropertiesPath}.Stream.Fn::GetAtt"));
+            Assert.Contains("Stream.Fn::GetAtt", syncedEventProperties[eventResourceName]);
+        }
+
+        public class DynamoDBEventsTestData : TheoryData<CloudFormationTemplateFormat, IEnumerable<DynamoDBEventAttribute>>
+        {
+            public DynamoDBEventsTestData()
+            {
+                foreach (var templateFormat in new List<CloudFormationTemplateFormat> { CloudFormationTemplateFormat.Json, CloudFormationTemplateFormat.Yaml })
+                {
+                    // Simple attribute
+                    Add(templateFormat, [new(streamArn1)]);
+
+                    // Multiple DynamoDBEvent attributes
+                    Add(templateFormat, [new(streamArn1), new(streamArn2)]);
+
+                    // Use table reference
+                    Add(templateFormat, [new("@MyTable")]);
+
+                    // Specify filters
+                    Add(templateFormat, [new(streamArn1) { Filters = "SOME-FILTER1; SOME-FILTER2" }]);
+
+                    // Explicitly specify all properties
+                    Add(templateFormat,
+                        [new(streamArn1)
+                        {
+                            BatchSize = 10,
+                            Filters = "SOME-FILTER1; SOME-FILTER2",
+                            MaximumBatchingWindowInSeconds = 15,
+                            Enabled = false,
+                            StartingPosition = "TRIM_HORIZON"
+                        }]);
+                }
+            }
+        }
+    }
+}
diff --git a/Libraries/test/TestServerlessApp/DynamoDBEventExamples/ValidDynamoDBEvents.cs.txt b/Libraries/test/TestServerlessApp/DynamoDBEventExamples/ValidDynamoDBEvents.cs.txt
new file mode 100644
index 000000000..a6fd76cda
--- /dev/null
+++ b/Libraries/test/TestServerlessApp/DynamoDBEventExamples/ValidDynamoDBEvents.cs.txt
@@ -0,0 +1,30 @@
+using Amazon.Lambda.Annotations;
+using Amazon.Lambda.Annotations.DynamoDB;
+using Amazon.Lambda.DynamoDBEvents;
+using System;
+using System.Threading.Tasks;
+
+namespace TestServerlessApp.DynamoDBEventExamples
+{
+    // This file represents valid usage of the DynamoDBEventAttribute. 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 ValidDynamoDBEvents
+    {
+        [LambdaFunction(PackageType = LambdaPackageType.Image)]
+        [DynamoDBEvent("arn:aws:dynamodb:us-east-2:444455556666:table/MyTable/stream/2024-01-01T00:00:00", BatchSize = 50, MaximumBatchingWindowInSeconds = 2, Filters = "My-Filter-1; My-Filter-2")]
+        [DynamoDBEvent("arn:aws:dynamodb:us-east-2:444455556666:table/MyTable2/stream/2024-01-01T00:00:00", StartingPosition = "TRIM_HORIZON", Enabled = false)]
+        [DynamoDBEvent("@testTable", ResourceName = "testTableEvent")]
+        public void ProcessMessages(DynamoDBEvent evnt)
+        {
+            Console.WriteLine($"Event processed: {evnt}");
+        }
+
+        [LambdaFunction(PackageType = LambdaPackageType.Image)]
+        [DynamoDBEvent("arn:aws:dynamodb:us-east-2:444455556666:table/MyTable/stream/2024-01-01T00:00:00")]
+        public async Task ProcessMessagesAsync(DynamoDBEvent evnt)
+        {
+            await Console.Out.WriteLineAsync($"Event processed: {evnt}");
+        }
+    }
+}
diff --git a/Libraries/test/TestServerlessApp/TestServerlessApp.csproj b/Libraries/test/TestServerlessApp/TestServerlessApp.csproj
index 921e3d372..238529e82 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.DynamoDBEvents\Amazon.Lambda.DynamoDBEvents.csproj" />
     <ProjectReference Include="..\..\src\Amazon.Lambda.Core\Amazon.Lambda.Core.csproj" />
     <ProjectReference Include="..\..\src\Amazon.Lambda.Serialization.SystemTextJson\Amazon.Lambda.Serialization.SystemTextJson.csproj" />
   </ItemGroup>