diff --git a/Code/CryEngine/CryCommon/IMovieSystem.h b/Code/CryEngine/CryCommon/IMovieSystem.h
index c22394e1b3..ca723eb6bd 100644
--- a/Code/CryEngine/CryCommon/IMovieSystem.h
+++ b/Code/CryEngine/CryCommon/IMovieSystem.h
@@ -696,7 +696,7 @@ public:
     //! Rotate entity node.
     virtual void SetRotate(float time, const Quat& quat) = 0;
     //! Scale entity node.
-    virtual void SetScale(float time, const Vec3& scale) = 0;
+    virtual void SetScale(float time, const float scale) = 0;
 
     //! Compute and return the offset which brings the current position to the given position
     virtual Vec3 GetOffsetPosition(const Vec3& position) { return position - GetPos(); }
@@ -708,7 +708,7 @@ public:
     //! Get entity rotation at specified time.
     virtual Quat GetRotate(float time) = 0;
     //! Get current entity scale.
-    virtual Vec3 GetScale() = 0;
+    virtual float GetScale() = 0;
 
     // General Set param.
     // Set float/vec3/vec4 parameter at given time.
diff --git a/Code/Framework/AzCore/AzCore/Component/TransformBus.h b/Code/Framework/AzCore/AzCore/Component/TransformBus.h
index 64af853e99..95c8f6e719 100644
--- a/Code/Framework/AzCore/AzCore/Component/TransformBus.h
+++ b/Code/Framework/AzCore/AzCore/Component/TransformBus.h
@@ -288,18 +288,26 @@ namespace AZ
         //! Scale modifiers
         //! @{
         //! Set local scale of the transform.
-        //! @param scale The new scale to set along three local axes.
+        //! @param scale The new scale to set.
         virtual void SetLocalScale([[maybe_unused]] const AZ::Vector3& scale) {}
 
-        //! Get the scale value on each axis in local space
-        //! @return The scale value of type Vector3 along each axis in local space.
+        //! Get the scale value in local space.
+        //! @return The scale value in local space.
         virtual AZ::Vector3 GetLocalScale() { return AZ::Vector3(FLT_MAX); }
 
-        //! Get the scale value on each axis in world space.
-        //! Note the transform will be skewed when it is rotated and has a parent transform scaled, in which
-        //! case the returned world-scale from this function will be inaccurate.
-        //! @return The scale value of type Vector3 along each axis in world space.
+        //! Get the scale value in world space.
+        //! @return The scale value in world space.
         virtual AZ::Vector3 GetWorldScale() { return AZ::Vector3(FLT_MAX); }
+
+
+        virtual void SetLocalUniformScale([[maybe_unused]] float scale) {}
+
+        virtual float GetLocalUniformScale() { return FLT_MAX; }
+
+        virtual float GetWorldUniformScale() { return FLT_MAX; }
+
+
+
         //! @}
 
         //! Transform hierarchy
diff --git a/Code/Framework/AzCore/AzCore/Math/Spline.h b/Code/Framework/AzCore/AzCore/Math/Spline.h
index 912c10f46f..1adfc9b2fa 100644
--- a/Code/Framework/AzCore/AzCore/Math/Spline.h
+++ b/Code/Framework/AzCore/AzCore/Math/Spline.h
@@ -441,10 +441,10 @@ namespace AZ
         const Transform& worldFromLocal, const Vector3& src, const Vector3& dir, const Spline& spline)
     {
         Transform worldFromLocalNormalized = worldFromLocal;
-        const Vector3 scale = worldFromLocalNormalized.ExtractScale();
+        const float scale = worldFromLocalNormalized.ExtractUniformScale();
         const Transform localFromWorldNormalized = worldFromLocalNormalized.GetInverse();
 
-        const Vector3 localRayOrigin = localFromWorldNormalized.TransformPoint(src) * scale.GetReciprocal();
+        const Vector3 localRayOrigin = localFromWorldNormalized.TransformPoint(src) / scale;
         const Vector3 localRayDirection = localFromWorldNormalized.TransformVector(dir);
         return spline.GetNearestAddressRay(localRayOrigin, localRayDirection);
     }
diff --git a/Code/Framework/AzCore/AzCore/Math/Transform.cpp b/Code/Framework/AzCore/AzCore/Math/Transform.cpp
index bb3f764492..ad57daa5e4 100644
--- a/Code/Framework/AzCore/AzCore/Math/Transform.cpp
+++ b/Code/Framework/AzCore/AzCore/Math/Transform.cpp
@@ -130,7 +130,7 @@ namespace AZ
         const Transform* transform = reinterpret_cast<const Transform*>(classPtr);
         float data[NumFloats];
         transform->GetRotation().StoreToFloat4(data);
-        transform->GetScale().StoreToFloat3(&data[4]);
+        Vector3(transform->GetScale()).StoreToFloat3(&data[4]);
         transform->GetTranslation().StoreToFloat3(&data[7]);
 
         for (int i = 0; i < NumFloats; i++)
@@ -220,7 +220,7 @@ namespace AZ
         Vector3 translation = Vector3::CreateFromFloat3(&data[7]);
 
         *reinterpret_cast<Transform*>(classPtr) =
-            Transform::CreateFromQuaternionAndTranslation(rotation, translation) * Transform::CreateScale(scale);
+            Transform::CreateFromQuaternionAndTranslation(rotation, translation) * Transform::CreateUniformScale(scale.GetMaxElement());
         return true;
     }
 
@@ -250,7 +250,7 @@ namespace AZ
                 Attribute(Script::Attributes::ExcludeFrom, Script::Attributes::ExcludeFlags::All)->
                 Attribute(Script::Attributes::Storage, Script::Attributes::StorageType::Value)->
                 Attribute(Script::Attributes::GenericConstructorOverride, &Internal::TransformDefaultConstructor)->
-                Constructor<const Vector3&, const Quaternion&, const Vector3&>()->
+                Constructor<const Vector3&, const Quaternion&, const float>()->
                 Method("GetBasis", &Transform::GetBasis)->
                 Method("GetBasisX", &Transform::GetBasisX)->
                 Method("GetBasisY", &Transform::GetBasisY)->
@@ -284,7 +284,7 @@ namespace AZ
                 Method("GetRotation", &Transform::GetRotation)->
                 Method<void (Transform::*)(const Quaternion&)>("SetRotation", &Transform::SetRotation)->
                 Method("GetScale", &Transform::GetScale)->
-                Method<void (Transform::*)(const Vector3&)>("SetScale", &Transform::SetScale)->
+                Method<void (Transform::*)(const Vector3&)>("SetScale", static_cast<void(Transform::*)(const Vector3&)>(&Transform::SetScale))->
                 Method("ExtractScale", &Transform::ExtractScale)->
                     Attribute(Script::Attributes::ExcludeFrom, Script::Attributes::ExcludeFlags::All)->
                 Method("MultiplyByScale", &Transform::MultiplyByScale)->
@@ -315,7 +315,7 @@ namespace AZ
     {
         Transform result;
         Matrix3x3 tmp = value;
-        result.m_scale = tmp.ExtractScale();
+        result.m_scale = tmp.ExtractScale().GetMaxElement();
         result.m_rotation = Quaternion::CreateFromMatrix3x3(tmp);
         result.m_translation = Vector3::CreateZero();
         return result;
@@ -325,7 +325,7 @@ namespace AZ
     {
         Transform result;
         Matrix3x3 tmp = value;
-        result.m_scale = tmp.ExtractScale();
+        result.m_scale = tmp.ExtractScale().GetMaxElement();
         result.m_rotation = Quaternion::CreateFromMatrix3x3(tmp);
         result.m_translation = p;
         return result;
@@ -335,7 +335,7 @@ namespace AZ
     {
         Transform result;
         Matrix3x4 tmp = value;
-        result.m_scale = tmp.ExtractScale();
+        result.m_scale = tmp.ExtractScale().GetMaxElement();
         result.m_rotation = Quaternion::CreateFromMatrix3x4(tmp);
         result.m_translation = value.GetTranslation();
         return result;
diff --git a/Code/Framework/AzCore/AzCore/Math/Transform.h b/Code/Framework/AzCore/AzCore/Math/Transform.h
index eb1a12a912..ba08722338 100644
--- a/Code/Framework/AzCore/AzCore/Math/Transform.h
+++ b/Code/Framework/AzCore/AzCore/Math/Transform.h
@@ -63,7 +63,7 @@ namespace AZ
         Transform() = default;
 
         //! Construct a transform from components.
-        Transform(const Vector3& translation, const Quaternion& rotation, const Vector3& scale);
+        Transform(const Vector3& translation, const Quaternion& rotation, const float scale);
 
         //! Creates an identity transform.
         static Transform CreateIdentity();
@@ -89,8 +89,11 @@ namespace AZ
 
         static Transform CreateFromMatrix3x4(const Matrix3x4& value);
 
-        //! Sets the matrix to be a scale matrix, translation is set to zero.
-        static Transform CreateScale(const Vector3& scale);
+        //! Sets the transform to apply (uniform) scale only, no rotation or translation.
+        static Transform CreateScale(const AZ::Vector3& scale);
+
+        //! Sets the transform to apply (uniform) scale only, no rotation or translation.
+        static Transform CreateUniformScale(const float scale);
 
         //! Sets the matrix to be a translation matrix, rotation part is set to identity.
         static Transform CreateTranslation(const Vector3& translation);
@@ -119,13 +122,19 @@ namespace AZ
         const Quaternion& GetRotation() const;
         void SetRotation(const Quaternion& rotation);
 
-        const Vector3& GetScale() const;
+        Vector3 GetScale() const;
+        float GetUniformScale() const;
         void SetScale(const Vector3& v);
+        void SetUniformScale(const float scale);
 
-        //! Sets the transforms scale to a unit value and returns the previous scale value.
+        //! Sets the transform's scale to a unit value and returns the previous scale value.
         Vector3 ExtractScale();
 
-        void MultiplyByScale(const Vector3& scale);
+        //! Sets the transform's scale to a unit value and returns the previous scale value.
+        float ExtractUniformScale();
+
+        void MultiplyByScale(const AZ::Vector3& scale);
+        void MultiplyByUniformScale(float scale);
 
         Transform operator*(const Transform& rhs) const;
         Transform& operator*=(const Transform& rhs);
@@ -159,7 +168,7 @@ namespace AZ
     private:
 
         Quaternion m_rotation;
-        Vector3 m_scale;
+        float m_scale;
         Vector3 m_translation;
     };
 
diff --git a/Code/Framework/AzCore/AzCore/Math/Transform.inl b/Code/Framework/AzCore/AzCore/Math/Transform.inl
index 63425e6e41..c92208da54 100644
--- a/Code/Framework/AzCore/AzCore/Math/Transform.inl
+++ b/Code/Framework/AzCore/AzCore/Math/Transform.inl
@@ -12,7 +12,7 @@
 
 namespace AZ
 {
-    AZ_MATH_INLINE Transform::Transform(const Vector3& translation, const Quaternion& rotation, const Vector3& scale)
+    AZ_MATH_INLINE Transform::Transform(const Vector3& translation, const Quaternion& rotation, const float scale)
         : m_translation(translation)
         , m_rotation(rotation)
         , m_scale(scale)
@@ -25,7 +25,7 @@ namespace AZ
     {
         Transform result;
         result.m_rotation = Quaternion::CreateIdentity();
-        result.m_scale = Vector3::CreateOne();
+        result.m_scale = 1.0f;
         result.m_translation = Vector3::CreateZero();
         return result;
     }
@@ -49,7 +49,7 @@ namespace AZ
     {
         Transform result;
         result.m_rotation = q;
-        result.m_scale = Vector3::CreateOne();
+        result.m_scale = 1.0f;
         result.m_translation = Vector3::CreateZero();
         return result;
     }
@@ -58,12 +58,22 @@ namespace AZ
     {
         Transform result;
         result.m_rotation = q;
-        result.m_scale = Vector3::CreateOne();
+        result.m_scale = 1.0f;
         result.m_translation = p;
         return result;
     }
 
-    AZ_MATH_INLINE Transform Transform::CreateScale(const Vector3& scale)
+    AZ_MATH_INLINE Transform Transform::CreateScale(const AZ::Vector3& scale)
+    {
+        AZ_Warning("Transform", false, "CreateScale is deprecated, please use CreateUniformScale instead.");
+        Transform result;
+        result.m_rotation = Quaternion::CreateIdentity();
+        result.m_scale = scale.GetMaxElement();
+        result.m_translation = Vector3::CreateZero();
+        return result;
+    }
+
+    AZ_MATH_INLINE Transform Transform::CreateUniformScale(float scale)
     {
         Transform result;
         result.m_rotation = Quaternion::CreateIdentity();
@@ -76,7 +86,7 @@ namespace AZ
     {
         Transform result;
         result.m_rotation = Quaternion::CreateIdentity();
-        result.m_scale = Vector3::CreateOne();
+        result.m_scale = 1.0f;
         result.m_translation = translation;
         return result;
     }
@@ -104,17 +114,17 @@ namespace AZ
 
     AZ_MATH_INLINE Vector3 Transform::GetBasisX() const
     {
-        return m_rotation.TransformVector(Vector3::CreateAxisX(m_scale.GetX()));
+        return m_rotation.TransformVector(Vector3::CreateAxisX(m_scale));
     }
 
     AZ_MATH_INLINE Vector3 Transform::GetBasisY() const
     {
-        return m_rotation.TransformVector(Vector3::CreateAxisY(m_scale.GetY()));
+        return m_rotation.TransformVector(Vector3::CreateAxisY(m_scale));
     }
 
     AZ_MATH_INLINE Vector3 Transform::GetBasisZ() const
     {
-        return m_rotation.TransformVector(Vector3::CreateAxisZ(m_scale.GetZ()));
+        return m_rotation.TransformVector(Vector3::CreateAxisZ(m_scale));
     }
 
     AZ_MATH_INLINE void Transform::GetBasisAndTranslation(Vector3* basisX, Vector3* basisY, Vector3* basisZ, Vector3* pos) const
@@ -150,24 +160,50 @@ namespace AZ
         m_rotation = rotation;
     }
 
-    AZ_MATH_INLINE const Vector3& Transform::GetScale() const
+    AZ_MATH_INLINE Vector3 Transform::GetScale() const
+    {
+        AZ_Warning("Transform", false, "GetScale is deprecated, please use GetUniformScale instead.");
+        return Vector3(m_scale);
+    }
+
+    AZ_MATH_INLINE float Transform::GetUniformScale() const
     {
         return m_scale;
     }
 
     AZ_MATH_INLINE void Transform::SetScale(const Vector3& scale)
+    {
+        AZ_Warning("Transform", false, "SetScale is deprecated, please use SetUniformScale instead.");
+        m_scale = scale.GetMaxElement();
+    }
+
+    AZ_MATH_INLINE void Transform::SetUniformScale(const float scale)
     {
         m_scale = scale;
     }
 
     AZ_MATH_INLINE Vector3 Transform::ExtractScale()
     {
-        const Vector3 scale = m_scale;
-        m_scale = Vector3::CreateOne();
+        AZ_Warning("Transform", false, "ExtractScale is deprecated, please use ExtractUniformScale instead.");
+        const float scale = m_scale;
+        m_scale = 1.0f;
+        return Vector3(scale);
+    }
+
+    AZ_MATH_INLINE float Transform::ExtractUniformScale()
+    {
+        const float scale = m_scale;
+        m_scale = 1.0f;
         return scale;
     }
 
-    AZ_MATH_INLINE void Transform::MultiplyByScale(const Vector3& scale)
+    AZ_MATH_INLINE void Transform::MultiplyByScale(const AZ::Vector3& scale)
+    {
+        AZ_Warning("Transform", false, "MultiplyByScale is deprecated, please use MultiplyByUniformScale instead.");
+        m_scale *= scale.GetMaxElement();
+    }
+
+    AZ_MATH_INLINE void Transform::MultiplyByUniformScale(float scale)
     {
         m_scale *= scale;
     }
@@ -207,7 +243,7 @@ namespace AZ
         // note - need to be careful about how to calculate inverse when there is non-uniform scale
         Transform out;
         out.m_rotation = m_rotation.GetConjugate();
-        out.m_scale = m_scale.GetReciprocal();
+        out.m_scale = 1.0f / m_scale;
         out.m_translation = -out.m_scale * (out.m_rotation.TransformVector(m_translation));
         return out;
     }
@@ -219,27 +255,27 @@ namespace AZ
 
     AZ_MATH_INLINE bool Transform::IsOrthogonal(float tolerance) const
     {
-        return m_scale.IsClose(Vector3::CreateOne(), tolerance);
+        return AZ::IsClose(m_scale, 1.0f, tolerance);
     }
 
     AZ_MATH_INLINE Transform Transform::GetOrthogonalized() const
     {
         Transform result;
         result.m_rotation = m_rotation;
-        result.m_scale = Vector3::CreateOne();
+        result.m_scale = 1.0f;
         result.m_translation = m_translation;
         return result;
     }
 
     AZ_MATH_INLINE void Transform::Orthogonalize()
     {
-        *this = GetOrthogonalized();
+        m_scale = 1.0f;
     }
 
     AZ_MATH_INLINE bool Transform::IsClose(const Transform& rhs, float tolerance) const
     {
         return m_rotation.IsClose(rhs.m_rotation, tolerance)
-            && m_scale.IsClose(rhs.m_scale, tolerance)
+            && AZ::IsClose(m_scale, rhs.m_scale, tolerance)
             && m_translation.IsClose(rhs.m_translation, tolerance);
     }
 
@@ -268,21 +304,21 @@ namespace AZ
     AZ_MATH_INLINE void Transform::SetFromEulerDegrees(const Vector3& eulerDegrees)
     {
         m_translation = Vector3::CreateZero();
-        m_scale = Vector3::CreateOne();
+        m_scale = 1.0f;
         m_rotation.SetFromEulerDegrees(eulerDegrees);
     }
 
     AZ_MATH_INLINE void Transform::SetFromEulerRadians(const Vector3& eulerRadians)
     {
         m_translation = Vector3::CreateZero();
-        m_scale = Vector3::CreateOne();
+        m_scale = 1.0f;
         m_rotation.SetFromEulerRadians(eulerRadians);
     }
 
     AZ_MATH_INLINE bool Transform::IsFinite() const
     {
         return m_rotation.IsFinite()
-            && m_scale.IsFinite()
+            && IsFiniteFloat(m_scale)
             && m_translation.IsFinite();
     }
 
diff --git a/Code/Framework/AzCore/AzCore/Math/TransformSerializer.cpp b/Code/Framework/AzCore/AzCore/Math/TransformSerializer.cpp
index 0a3e02ee0d..46440ac000 100644
--- a/Code/Framework/AzCore/AzCore/Math/TransformSerializer.cpp
+++ b/Code/Framework/AzCore/AzCore/Math/TransformSerializer.cpp
@@ -58,9 +58,7 @@ namespace AZ
         }
 
         {
-            // Scale is transitioning to a single uniform scale value, but since it's still internally represented as a Vector3,
-            // we need to pick one number to use for load/store operations.
-            float scale = transformInstance->GetScale().GetMaxElement();
+            float scale = transformInstance->GetUniformScale();
 
             JSR::ResultCode loadResult =
                 ContinueLoadingFromJsonObjectField(&scale, azrtti_typeid<decltype(scale)>(), inputValue, ScaleTag, context);
@@ -122,10 +120,8 @@ namespace AZ
         {
             AZ::ScopedContextPath subPathName(context, ScaleTag);
 
-            // Scale is transitioning to a single uniform scale value, but since it's still internally represented as a Vector3,
-            // we need to pick one number to use for load/store operations.
-            float scale = transformInstance->GetScale().GetMaxElement();
-            float defaultScale = defaultTransformInstance ? defaultTransformInstance->GetScale().GetMaxElement() : 0.0f;
+            float scale = transformInstance->GetUniformScale();
+            float defaultScale = defaultTransformInstance ? defaultTransformInstance->GetUniformScale() : 0.0f;
 
             JSR::ResultCode storeResult = ContinueStoringToJsonObjectField(
                 outputValue, ScaleTag, &scale, defaultTransformInstance ? &defaultScale : nullptr, azrtti_typeid<decltype(scale)>(),
diff --git a/Code/Framework/AzCore/Tests/Math/MathTestData.h b/Code/Framework/AzCore/Tests/Math/MathTestData.h
index cd3ade7854..c82c5caea7 100644
--- a/Code/Framework/AzCore/Tests/Math/MathTestData.h
+++ b/Code/Framework/AzCore/Tests/Math/MathTestData.h
@@ -61,8 +61,8 @@ namespace MathTestData
     };
 
     static const AZ::Transform NonOrthogonalTransforms[] = {
-    AZ::Transform::CreateScale(AZ::Vector3(2.4f, 0.3f, 1.7f)),
-    AZ::Transform::CreateRotationX(2.2f) * AZ::Transform::CreateScale(AZ::Vector3(0.2f, 0.8f, 1.4f))
+        AZ::Transform::CreateUniformScale(2.4f),
+        AZ::Transform::CreateRotationX(2.2f) * AZ::Transform::CreateUniformScale(0.8f)
     };
 
     static const AZ::Transform OrthogonalTransforms[] = {
diff --git a/Code/Framework/AzCore/Tests/Math/ObbTests.cpp b/Code/Framework/AzCore/Tests/Math/ObbTests.cpp
index a90d66f288..de267b4265 100644
--- a/Code/Framework/AzCore/Tests/Math/ObbTests.cpp
+++ b/Code/Framework/AzCore/Tests/Math/ObbTests.cpp
@@ -59,11 +59,11 @@ namespace UnitTest
     TEST(MATH_Obb, TestScaleTransform)
     {
         Obb obb = Obb::CreateFromPositionRotationAndHalfLengths(position, rotation, halfLengths);
-        Vector3 scaleFactors = Vector3(1.0f, 2.0f, 3.0f);
-        Transform transform = Transform::CreateScale(scaleFactors);
+        float scale = 3.0f;
+        Transform transform = Transform::CreateUniformScale(scale);
         obb = transform * obb;
-        EXPECT_THAT(obb.GetPosition(), IsClose(Vector3(1.0f, 4.0f, 9.0f)));
-        EXPECT_THAT(obb.GetHalfLengths(), IsClose(Vector3(0.5f, 1.0f, 1.5f)));
+        EXPECT_THAT(obb.GetPosition(), IsClose(Vector3(3.0f, 6.0f, 9.0f)));
+        EXPECT_THAT(obb.GetHalfLengths(), IsClose(Vector3(1.5f, 1.5f, 1.5f)));
     }
 
     TEST(MATH_Obb, TestSetPosition)
diff --git a/Code/Framework/AzCore/Tests/Math/TransformPerformanceTests.cpp b/Code/Framework/AzCore/Tests/Math/TransformPerformanceTests.cpp
index 400a845913..a9788375ad 100644
--- a/Code/Framework/AzCore/Tests/Math/TransformPerformanceTests.cpp
+++ b/Code/Framework/AzCore/Tests/Math/TransformPerformanceTests.cpp
@@ -186,7 +186,7 @@ namespace Benchmark
         {
             for (auto& testData : m_testDataArray)
             {
-                AZ::Transform result = AZ::Transform::CreateScale(testData.v3);
+                AZ::Transform result = AZ::Transform::CreateUniformScale(testData.value[0]);
                 benchmark::DoNotOptimize(result);
             }
         }
@@ -350,7 +350,7 @@ namespace Benchmark
         {
             for (auto& testData : m_testDataArray)
             {
-                AZ::Vector3 result = testData.t1.GetScale();
+                float result = testData.t1.GetUniformScale();
                 benchmark::DoNotOptimize(result);
             }
         }
@@ -376,7 +376,7 @@ namespace Benchmark
             for (auto& testData : m_testDataArray)
             {
                 AZ::Transform testTransform = testData.t2;
-                AZ::Vector3 result = testTransform.ExtractScale();
+                float result = testTransform.ExtractUniformScale();
                 benchmark::DoNotOptimize(result);
             }
         }
diff --git a/Code/Framework/AzCore/Tests/Math/TransformTests.cpp b/Code/Framework/AzCore/Tests/Math/TransformTests.cpp
index d0343211c3..49607573ce 100644
--- a/Code/Framework/AzCore/Tests/Math/TransformTests.cpp
+++ b/Code/Framework/AzCore/Tests/Math/TransformTests.cpp
@@ -184,12 +184,12 @@ namespace UnitTest
 
     TEST(MATH_Transform, CreateScale)
     {
-        const AZ::Vector3 scale(1.7f, 0.3f, 2.4f);
-        const AZ::Transform transform = AZ::Transform::CreateScale(scale);
+        const float scale = 1.7f;
+        const AZ::Transform transform = AZ::Transform::CreateUniformScale(scale);
         const AZ::Vector3 vector(0.2f, -1.6f, 0.4f);
         EXPECT_THAT(transform.GetTranslation(), IsClose(AZ::Vector3::CreateZero()));
         const AZ::Vector3 transformedVector = transform.TransformPoint(vector);
-        const AZ::Vector3 expected(0.34f, -0.48f, 0.96f);
+        const AZ::Vector3 expected(0.34f, -2.72f, 0.68f);
         EXPECT_THAT(transformedVector, IsClose(expected));
     }
 
@@ -237,10 +237,10 @@ namespace UnitTest
     TEST(MATH_Transform, MultiplyByTransform)
     {
         const AZ::Transform transform1 = AZ::Transform::CreateRotationY(0.3f);
-        const AZ::Transform transform2 = AZ::Transform::CreateScale(AZ::Vector3(1.3f, 1.5f, 0.4f));
+        const AZ::Transform transform2 = AZ::Transform::CreateUniformScale(1.3f);
         const AZ::Transform transform3 = AZ::Transform::CreateFromQuaternionAndTranslation(
             AZ::Quaternion(0.42f, 0.46f, -0.66f, 0.42f), AZ::Vector3(2.8f, -3.7f, 1.6f));
-        const AZ::Transform transform4 = AZ::Transform::CreateRotationX(-0.7f) * AZ::Transform::CreateScale(AZ::Vector3(0.6f, 1.3f, 0.7f));
+        const AZ::Transform transform4 = AZ::Transform::CreateRotationX(-0.7f) * AZ::Transform::CreateUniformScale(0.6f);
         AZ::Transform transform5 = transform1;
         transform5 *= transform4;
         const AZ::Vector3 vector(1.9f, 2.3f, 0.2f);
@@ -341,10 +341,10 @@ namespace UnitTest
         AZ::Transform unscaledTransform = orthogonalTransform;
         unscaledTransform.ExtractScale();
         EXPECT_THAT(unscaledTransform.GetScale(), IsClose(AZ::Vector3::CreateOne()));
-        const AZ::Vector3 scale(2.8f, 0.7f, 1.3f);
+        const float scale = 2.8f;
         AZ::Transform scaledTransform = orthogonalTransform;
-        scaledTransform.MultiplyByScale(scale);
-        EXPECT_THAT(scaledTransform.GetScale(), IsClose(scale));
+        scaledTransform.MultiplyByUniformScale(scale);
+        EXPECT_NEAR(scaledTransform.GetUniformScale(), scale, AZ::Constants::Tolerance);
     }
 
     INSTANTIATE_TEST_CASE_P(MATH_Transform, TransformScaleFixture, ::testing::ValuesIn(MathTestData::OrthogonalTransforms));
@@ -353,24 +353,11 @@ namespace UnitTest
     {
         EXPECT_TRUE(AZ::Transform::CreateIdentity().IsOrthogonal());
         EXPECT_TRUE(AZ::Transform::CreateRotationZ(0.3f).IsOrthogonal());
-        EXPECT_FALSE(AZ::Transform::CreateScale(AZ::Vector3(0.8f, 0.3f, 1.2f)).IsOrthogonal());
+        EXPECT_FALSE(AZ::Transform::CreateUniformScale(0.8f).IsOrthogonal());
         EXPECT_TRUE(AZ::Transform::CreateFromQuaternion(AZ::Quaternion(-0.52f, -0.08f, 0.56f, 0.64f)).IsOrthogonal());
         AZ::Transform transform;
         transform.SetFromEulerRadians(AZ::Vector3(0.2f, 0.4f, 0.1f));
         EXPECT_TRUE(transform.IsOrthogonal());
-
-        // want to test each possible way the transform could fail to be orthogonal, which we can do by testing for one
-        // axis, then using a rotation which cycles the axes
-        const AZ::Transform axisCycle = AZ::Transform::CreateFromQuaternion(AZ::Quaternion(0.5f, 0.5f, 0.5f, 0.5f));
-
-        // a transform which is normalized in 2 axes, but not the third
-        AZ::Transform nonOrthogonalTransform1 = AZ::Transform::CreateScale(AZ::Vector3(1.0f, 1.0f, 2.0f));
-
-        for (int i = 0; i < 3; i++)
-        {
-            EXPECT_FALSE(nonOrthogonalTransform1.IsOrthogonal());
-            nonOrthogonalTransform1 = axisCycle * nonOrthogonalTransform1;
-        }
     }
 
     using TransformSetFromEulerDegreesFixture = ::testing::TestWithParam<AZ::Vector3>;
@@ -465,10 +452,11 @@ namespace UnitTest
         AZ::Transform* deserializedTransform = AZ::Utils::LoadObjectFromBuffer<AZ::Transform>(objectStreamBuffer, strlen(objectStreamBuffer) + 1);
 
         const AZ::Vector3 expectedTranslation(513.7845459f, 492.5420837f, 32.0000000f);
-        const AZ::Vector3 expectedScale(1.5f, 0.5f, 1.2f);
+        const float expectedScale = 1.5f;
         const AZ::Quaternion expectedRotation(0.2624075f, 0.4405251f, 0.2029076f, 0.8342113f);
         const AZ::Transform expectedTransform =
-            AZ::Transform::CreateFromQuaternionAndTranslation(expectedRotation, expectedTranslation) * AZ::Transform::CreateScale(expectedScale);
+            AZ::Transform::CreateFromQuaternionAndTranslation(expectedRotation, expectedTranslation) *
+            AZ::Transform::CreateUniformScale(expectedScale);
 
         EXPECT_TRUE(deserializedTransform->IsClose(expectedTransform));
         azfree(deserializedTransform);
diff --git a/Code/Framework/AzCore/Tests/ScriptMath.cpp b/Code/Framework/AzCore/Tests/ScriptMath.cpp
index cb673e92e7..493a21de36 100644
--- a/Code/Framework/AzCore/Tests/ScriptMath.cpp
+++ b/Code/Framework/AzCore/Tests/ScriptMath.cpp
@@ -1275,10 +1275,10 @@ namespace UnitTest
         script->Execute("AZTestAssert(t1:TransformVector(Vector3(1, 0, 0)):IsClose(Vector3(1, 0, 0)))");
         script->Execute("AZTestAssert(t1:TransformVector(Vector3(0, 1, 0)):IsClose(Vector3(0, 0.866, 0.5)))");
         script->Execute("AZTestAssert(t1:TransformVector(Vector3(0, 0, 1)):IsClose(Vector3(0, -0.5, 0.866)))");
-        script->Execute("t1 = Transform.CreateScale(Vector3(1, 2, 3))");
-        script->Execute("AZTestAssert(t1:TransformVector(Vector3(1, 0, 0)):IsClose(Vector3(1, 0, 0)))");
+        script->Execute("t1 = Transform.CreateScale(2)");
+        script->Execute("AZTestAssert(t1:TransformVector(Vector3(1, 0, 0)):IsClose(Vector3(2, 0, 0)))");
         script->Execute("AZTestAssert(t1:TransformVector(Vector3(0, 1, 0)):IsClose(Vector3(0, 2, 0)))");
-        script->Execute("AZTestAssert(t1:TransformVector(Vector3(0, 0, 1)):IsClose(Vector3(0, 0, 3)))");
+        script->Execute("AZTestAssert(t1:TransformVector(Vector3(0, 0, 1)):IsClose(Vector3(0, 0, 2)))");
         script->Execute("t1 = Transform.CreateTranslation(Vector3(1, 2, 3))");
         script->Execute("AZTestAssert(t1:TransformVector(Vector3(1, 0, 0)):IsClose(Vector3(1, 0, 0)))");
         script->Execute("AZTestAssert(t1:TransformVector(Vector3(0, 1, 0)):IsClose(Vector3(0, 1, 0)))");
@@ -1341,19 +1341,19 @@ namespace UnitTest
         script->Execute("AZTestAssert(t3:GetTranslation():IsClose(Vector3(-5.90, 25.415, 19.645), 0.001))");
 
         ////test inverse, should handle non-orthogonal matrices
-        script->Execute("t1 = Transform.CreateRotationX(1) * Transform.CreateScale(Vector3(1, 2, 3))");
+        script->Execute("t1 = Transform.CreateRotationX(1) * Transform.CreateScale(2)");
         script->Execute("AZTestAssert((t1*t1:GetInverse()):IsClose(Transform.CreateIdentity()))");
 
         ////scale access
-        script->Execute("t1 = Transform.CreateRotationX(Math.DegToRad(40)) * Transform.CreateScale(Vector3(2, 3, 4))");
-        script->Execute("AZTestAssert(t1:GetScale():IsClose(Vector3(2, 3, 4)))");
-        script->Execute("AZTestAssert(t1:ExtractScale():IsClose(Vector3(2, 3, 4)))");
-        script->Execute("AZTestAssert(t1:GetScale():IsClose(Vector3.CreateOne()))");
-        script->Execute("t1:MultiplyByScale(Vector3(3, 4, 5))");
-        script->Execute("AZTestAssert(t1:GetScale():IsClose(Vector3(3, 4, 5)))");
+        script->Execute("t1 = Transform.CreateRotationX(Math.DegToRad(40)) * Transform.CreateScale(3)");
+        script->Execute("AZTestAssert(t1:GetScale():IsClose(3))");
+        script->Execute("AZTestAssert(t1:ExtractScale():IsClose(3))");
+        script->Execute("AZTestAssert(t1:GetScale():IsClose(1))");
+        script->Execute("t1:MultiplyByScale(2)");
+        script->Execute("AZTestAssert(t1:GetScale():IsClose(2))");
 
         ////orthogonalize
-        script->Execute("t1 = Transform.CreateRotationX(Math.DegToRad(30)) * Transform.CreateScale(Vector3(2, 3, 4))");
+        script->Execute("t1 = Transform.CreateRotationX(Math.DegToRad(30)) * Transform.CreateScale(3)");
         script->Execute("t1:SetTranslation(Vector3(1,2,3))");
         script->Execute("t2 = t1:GetOrthogonalized()");
         script->Execute("AZTestAssertFloatClose(t2:GetBasisX():GetLength(), 1)");
@@ -1372,7 +1372,7 @@ namespace UnitTest
         script->Execute("t1 = Transform.CreateRotationX(Math.DegToRad(30))");
         script->Execute("t1:SetTranslation(Vector3(1, 2, 3))");
         script->Execute("AZTestAssert(t1:IsOrthogonal(0.05))");
-        script->Execute("t1 = Transform.CreateRotationX(Math.DegToRad(30)) * Transform.CreateScale(Vector3(2, 3, 4))");
+        script->Execute("t1 = Transform.CreateRotationX(Math.DegToRad(30)) * Transform.CreateScale(2)");
         script->Execute("AZTestAssert( not t1:IsOrthogonal(0.05))");
 
         ////IsClose
diff --git a/Code/Framework/AzCore/Tests/Serialization/Json/TransformSerializerTests.cpp b/Code/Framework/AzCore/Tests/Serialization/Json/TransformSerializerTests.cpp
index 12711b1e1a..7febbbb5d9 100644
--- a/Code/Framework/AzCore/Tests/Serialization/Json/TransformSerializerTests.cpp
+++ b/Code/Framework/AzCore/Tests/Serialization/Json/TransformSerializerTests.cpp
@@ -44,7 +44,7 @@ namespace JsonSerializationTests
         AZStd::shared_ptr<AZ::Transform> CreateFullySetInstance() override
         {
             return AZStd::make_shared<AZ::Transform>(
-                AZ::Vector3(1.0f, 2.0f, 3.0f), AZ::Quaternion(0.25f, 0.5f, 0.75f, 1.0f), AZ::Vector3(9.0f));
+                AZ::Vector3(1.0f, 2.0f, 3.0f), AZ::Quaternion(0.25f, 0.5f, 0.75f, 1.0f), 9.0f);
         }
 
         AZStd::string_view GetJsonForFullySetInstance() override
@@ -95,7 +95,7 @@ namespace JsonSerializationTests
         AZ::Transform expectedTransform(
             AZ::Vector3(2.25f, 3.5f, 4.75f),
             AZ::Quaternion(0.25f, 0.5f, 0.75f, 1.0f),
-            AZ::Vector3(5.5f));
+            5.5f);
 
         rapidjson::Document json;
         json.Parse(R"({ "Translation": [ 2.25, 3.5, 4.75 ], "Rotation": [ 0.25, 0.5, 0.75, 1.0 ], "Scale": 5.5 })");
@@ -189,7 +189,7 @@ namespace JsonSerializationTests
     TEST_F(JsonTransformSerializerTests, Load_FullySetTransform_ReturnsSuccessWithOnlyScale)
     {
         AZ::Transform testTransform = AZ::Transform::CreateIdentity();
-        AZ::Transform expectedTransform = AZ::Transform::CreateScale(AZ::Vector3(5.5f));
+        AZ::Transform expectedTransform = AZ::Transform::CreateUniformScale(5.5f);
 
         rapidjson::Document json;
         json.Parse(R"({ "Scale" : 5.5 })");
diff --git a/Code/Framework/AzFramework/AzFramework/Components/TransformComponent.cpp b/Code/Framework/AzFramework/AzFramework/Components/TransformComponent.cpp
index 4b805fd3e1..b1b2378174 100644
--- a/Code/Framework/AzFramework/AzFramework/Components/TransformComponent.cpp
+++ b/Code/Framework/AzFramework/AzFramework/Components/TransformComponent.cpp
@@ -447,29 +447,12 @@ namespace AzFramework
 
     static AZ::Transform RotateAroundLocalHelper(float eulerAngleRadian, const AZ::Transform& localTM, AZ::Vector3 axis)
     {
-        //get the existing translation and scale
-        AZ::Vector3 translation = localTM.GetTranslation();
-        AZ::Vector3 scale = localTM.GetScale();
-
         //normalize the axis before creating rotation
         axis.Normalize();
         AZ::Quaternion rotate = AZ::Quaternion::CreateFromAxisAngle(axis, eulerAngleRadian);
 
-        //create new rotation transform
-        AZ::Quaternion currentRotate = localTM.GetRotation();
-        AZ::Quaternion newRotate = rotate * currentRotate;
-        newRotate.Normalize();
-
-        //scale
-        AZ::Transform newLocalTM = AZ::Transform::CreateScale(scale);
-
-        //rotate
-        AZ::Transform rotateLocalTM = AZ::Transform::CreateFromQuaternion(newRotate);
-        newLocalTM = rotateLocalTM * newLocalTM;
-
-        //translate
-        newLocalTM.SetTranslation(translation);
-
+        AZ::Transform newLocalTM = localTM;
+        newLocalTM.SetRotation((rotate * localTM.GetRotation()).GetNormalized());
         return newLocalTM;
     }
 
@@ -527,6 +510,23 @@ namespace AzFramework
         return m_worldTM.GetScale();
     }
 
+    void TransformComponent::SetLocalUniformScale(float scale)
+    {
+        AZ::Transform newLocalTM = m_localTM;
+        newLocalTM.SetUniformScale(scale);
+        SetLocalTM(newLocalTM);
+    }
+
+    float TransformComponent::GetLocalUniformScale()
+    {
+        return m_localTM.GetUniformScale();
+    }
+
+    float TransformComponent::GetWorldUniformScale()
+    {
+        return m_worldTM.GetUniformScale();
+    }
+
     AZStd::vector<AZ::EntityId> TransformComponent::GetChildren()
     {
         AZStd::vector<AZ::EntityId> children;
diff --git a/Code/Framework/AzFramework/AzFramework/Components/TransformComponent.h b/Code/Framework/AzFramework/AzFramework/Components/TransformComponent.h
index f393e22064..f0fa1b6985 100644
--- a/Code/Framework/AzFramework/AzFramework/Components/TransformComponent.h
+++ b/Code/Framework/AzFramework/AzFramework/Components/TransformComponent.h
@@ -146,10 +146,13 @@ namespace AzFramework
 
         // Scale Modifiers
         void SetLocalScale(const AZ::Vector3& scale) override;
-
         AZ::Vector3 GetLocalScale() override;
         AZ::Vector3 GetWorldScale() override;
 
+        void SetLocalUniformScale(float scale) override;
+        float GetLocalUniformScale() override;
+        float GetWorldUniformScale() override;
+
         // Transform hierarchy
         AZStd::vector<AZ::EntityId> GetChildren() override;
         AZStd::vector<AZ::EntityId> GetAllDescendants() override;
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ScaleManipulators.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ScaleManipulators.cpp
index 3af09f644d..caeedd834f 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ScaleManipulators.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ScaleManipulators.cpp
@@ -82,9 +82,7 @@ namespace AzToolsFramework
 
         m_uniformScaleManipulator->SetVisualOrientationOverride(
             QuaternionFromTransformNoScaling(localTransform));
-        m_uniformScaleManipulator->SetLocalTransform(
-            AZ::Transform::CreateTranslation(localTransform.GetTranslation()) *
-            AZ::Transform::CreateScale(localTransform.GetScale()));
+        m_uniformScaleManipulator->SetLocalOrientation(AZ::Quaternion::CreateIdentity());
     }
 
     void ScaleManipulators::SetLocalPositionImpl(const AZ::Vector3& localPosition)
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceUtilities.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceUtilities.cpp
index 75070d9b41..e13d4fdb47 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceUtilities.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceUtilities.cpp
@@ -1475,10 +1475,8 @@ namespace AzToolsFramework
                     // to avoid pushing them to the slice.
                     // Only scale is preserved on the root entity of a slice.
                     transformComponent->SetParent(AZ::EntityId());
-                    AZ::Vector3 scale = transformComponent->GetLocalScale();
                     transformComponent->SetWorldTranslation(AZ::Vector3::CreateZero());
                     transformComponent->SetLocalRotation(AZ::Vector3::CreateZero());
-                    transformComponent->SetLocalScale(scale);
                 }
             }
 
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponent.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponent.cpp
index 671a56b4d4..bcd8e3fa4a 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponent.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponent.cpp
@@ -46,9 +46,9 @@ namespace AzToolsFramework
             const AZ::u32 ParentEntityCRC = AZ_CRC("Parent Entity", 0x5b1b276c);
 
             // Decompose a transform into euler angles in degrees, scale (along basis, any shear will be dropped), and translation.
-            void DecomposeTransform(const AZ::Transform& transform, AZ::Vector3& translation, AZ::Vector3& rotation, AZ::Vector3& scale)
+            void DecomposeTransform(const AZ::Transform& transform, AZ::Vector3& translation, AZ::Vector3& rotation, float& scale)
             {
-                scale = transform.GetScale();
+                scale = transform.GetUniformScale();
                 translation = transform.GetTranslation();
                 rotation = transform.GetRotation().GetEulerDegrees();
             }
@@ -323,7 +323,7 @@ namespace AzToolsFramework
 
         AZ::Transform TransformComponent::GetLocalScaleTM() const
         {
-            return AZ::Transform::CreateScale(m_editorTransform.m_scale);
+            return AZ::Transform::CreateUniformScale(m_editorTransform.m_scale);
         }
 
         const AZ::Transform& TransformComponent::GetLocalTM()
@@ -340,7 +340,8 @@ namespace AzToolsFramework
         // given a local transform, update local transform.
         void TransformComponent::SetLocalTM(const AZ::Transform& finalTx)
         {
-            AZ::Vector3 tx, rot, scale;
+            AZ::Vector3 tx, rot;
+            float scale;
             Internal::DecomposeTransform(finalTx, tx, rot, scale);
 
             m_editorTransform.m_translate = tx;
@@ -645,13 +646,13 @@ namespace AzToolsFramework
 
         void TransformComponent::SetLocalScale(const AZ::Vector3& scale)
         {
-            m_editorTransform.m_scale = scale;
+            m_editorTransform.m_scale = scale.GetMaxElement();
             TransformChanged();
         }
 
         AZ::Vector3 TransformComponent::GetLocalScale()
         {
-            return m_editorTransform.m_scale;
+            return AZ::Vector3(m_editorTransform.m_scale);
         }
 
         AZ::Vector3 TransformComponent::GetWorldScale()
@@ -659,6 +660,22 @@ namespace AzToolsFramework
             return GetWorldTM().GetScale();
         }
 
+        void TransformComponent::SetLocalUniformScale(float scale)
+        {
+            m_editorTransform.m_scale = scale;
+            TransformChanged();
+        }
+
+        float TransformComponent::GetLocalUniformScale()
+        {
+            return m_editorTransform.m_scale;
+        }
+
+        float TransformComponent::GetWorldUniformScale()
+        {
+            return GetWorldTM().GetUniformScale();
+        }
+
         const AZ::Transform& TransformComponent::GetParentWorldTM() const
         {
             auto parent = GetParentTransformComponent();
@@ -1062,12 +1079,6 @@ namespace AzToolsFramework
             ModifyEditorTransform(m_editorTransform.m_rotate, data, parent);
         }
 
-        void TransformComponent::ScaleBy(const AZ::Vector3& data)
-        {
-            //scale is always local
-            ModifyEditorTransform(m_editorTransform.m_scale, data, AZ::Transform::Identity());
-        }
-
         AZ::EntityId TransformComponent::GetSliceEntityParentId()
         {
             return GetParentId();
@@ -1214,7 +1225,7 @@ namespace AzToolsFramework
                     {
                         AzToolsFramework::ScopedUndoBatch undo("Reset transform values");
                         m_editorTransform.m_translate = AZ::Vector3::CreateZero();
-                        m_editorTransform.m_scale = AZ::Vector3::CreateOne();
+                        m_editorTransform.m_scale = 1.0f;
                         m_editorTransform.m_rotate = AZ::Vector3::CreateZero();
                         OnTransformChanged();
                         SetDirty();
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponent.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponent.h
index bbdf770dab..06d1101c58 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponent.h
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponent.h
@@ -130,10 +130,13 @@ namespace AzToolsFramework
 
             // Scale Modifiers
             void SetLocalScale(const AZ::Vector3& scale) override;
-
             AZ::Vector3 GetLocalScale() override;
             AZ::Vector3 GetWorldScale() override;
 
+            void SetLocalUniformScale(float scale) override;
+            float GetLocalUniformScale() override;
+            float GetWorldUniformScale() override;
+
             AZ::EntityId  GetParentId() override;
             AZ::TransformInterface* GetParent() override;
             void SetParent(AZ::EntityId parentId) override;
@@ -147,7 +150,6 @@ namespace AzToolsFramework
             // TransformComponentMessages::Bus
             void TranslateBy(const AZ::Vector3&) override;
             void RotateBy(const AZ::Vector3&) override; // euler in degrees
-            void ScaleBy(const AZ::Vector3&) override;
             const EditorTransform& GetLocalEditorTransform() override;
             void SetLocalEditorTransform(const EditorTransform& dest) override;
             bool IsTransformLocked() override;
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponentBus.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponentBus.h
index f1cb8459c4..6082bda4bd 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponentBus.h
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponentBus.h
@@ -30,7 +30,7 @@ namespace AzToolsFramework
             EditorTransform()
             {
                 m_translate = AZ::Vector3::CreateZero();
-                m_scale = AZ::Vector3::CreateOne();
+                m_scale = 1.0f;
                 m_rotate = AZ::Vector3::CreateZero();
                 m_locked = false;
             }
@@ -41,7 +41,7 @@ namespace AzToolsFramework
             }
 
             AZ::Vector3 m_translate; //! Translation in engine units (meters)
-            AZ::Vector3 m_scale;
+            float m_scale;
             AZ::Vector3 m_rotate; //! Rotation in degrees
             bool m_locked;
         };
@@ -65,7 +65,6 @@ namespace AzToolsFramework
 
             virtual void TranslateBy(const AZ::Vector3&) = 0;
             virtual void RotateBy(const AZ::Vector3&) = 0;
-            virtual void ScaleBy(const AZ::Vector3&) = 0;
 
             virtual bool IsTransformLocked() = 0;
         };
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.cpp
index 433602e6d8..65ba51908d 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.cpp
@@ -1472,7 +1472,7 @@ namespace AzToolsFramework
                         {
                             const AZ::Quaternion rotation = entityIdLookupIt->second.m_initial.GetRotation().GetNormalized();
                             const AZ::Vector3 position = entityIdLookupIt->second.m_initial.GetTranslation();
-                            const AZ::Vector3 scale = entityIdLookupIt->second.m_initial.GetScale();
+                            const float scale = entityIdLookupIt->second.m_initial.GetUniformScale();
 
                             const AZ::Vector3 centerOffset = CalculateCenterOffset(entityId, m_pivotMode);
 
@@ -1483,7 +1483,7 @@ namespace AzToolsFramework
                                     AZ::Transform::CreateFromQuaternion(rotation) *
                                     AZ::Transform::CreateTranslation(centerOffset) * offsetRotation *
                                     AZ::Transform::CreateTranslation(-centerOffset) *
-                                    AZ::Transform::CreateScale(scale));
+                                    AZ::Transform::CreateUniformScale(scale));
                         }
                         break;
                     case ReferenceFrame::Parent:
@@ -1595,16 +1595,15 @@ namespace AzToolsFramework
                 }
 
                 const AZ::Transform initial = entityIdLookupIt->second.m_initial;
-                const AZ::Vector3 initialScale = initial.GetScale();
+                const float initialScale = initial.GetUniformScale();
 
                 const auto sumVectorElements = [](const AZ::Vector3& vec) {
                     return vec.GetX() + vec.GetY() + vec.GetZ();
                 };
 
-                const AZ::Vector3 uniformScale = AZ::Vector3(action.m_start.m_sign * sumVectorElements(action.LocalScaleOffset()));
-                const AZ::Vector3 scale = (AZ::Vector3::CreateOne() +
-                    (uniformScale / initialScale)).GetClamp(AZ::Vector3(AZ::MinTransformScale), AZ::Vector3(AZ::MaxTransformScale));
-                const AZ::Transform scaleTransform = AZ::Transform::CreateScale(scale);
+                const float uniformScale = action.m_start.m_sign * sumVectorElements(action.LocalScaleOffset());
+                const float scale = AZ::GetClamp(1.0f + uniformScale / initialScale, AZ::MinTransformScale, AZ::MaxTransformScale);
+                const AZ::Transform scaleTransform = AZ::Transform::CreateUniformScale(scale);
 
                 if (action.m_modifiers.Alt())
                 {
@@ -1866,7 +1865,7 @@ namespace AzToolsFramework
                         CopyOrientationToSelectedEntitiesGroup(QuaternionFromTransformNoScaling(worldFromLocal));
                         break;
                     case Mode::Scale:
-                        CopyScaleToSelectedEntitiesIndividualWorld(worldFromLocal.GetScale());
+                        CopyScaleToSelectedEntitiesIndividualWorld(worldFromLocal.GetUniformScale());
                         break;
                     case Mode::Translation:
                         CopyTranslationToSelectedEntitiesGroup(worldFromLocal.GetTranslation());
@@ -1895,7 +1894,7 @@ namespace AzToolsFramework
                         CopyOrientationToSelectedEntitiesIndividual(QuaternionFromTransformNoScaling(worldFromLocal));
                         break;
                     case Mode::Scale:
-                        CopyScaleToSelectedEntitiesIndividualWorld(worldFromLocal.GetScale());
+                        CopyScaleToSelectedEntitiesIndividualWorld(worldFromLocal.GetUniformScale());
                         break;
                     case Mode::Translation:
                         CopyTranslationToSelectedEntitiesIndividual(worldFromLocal.GetTranslation());
@@ -2388,7 +2387,7 @@ namespace AzToolsFramework
                 ResetOrientationForSelectedEntitiesLocal();
                 break;
             case Mode::Scale:
-                CopyScaleToSelectedEntitiesIndividualLocal(AZ::Vector3::CreateOne());
+                CopyScaleToSelectedEntitiesIndividualLocal(1.0f);
                 break;
             case Mode::Translation:
                 ResetTranslationForSelectedEntitiesLocal();
@@ -2414,7 +2413,7 @@ namespace AzToolsFramework
                 ResetOrientationForSelectedEntitiesLocal();
                 break;
             case Mode::Scale:
-                CopyScaleToSelectedEntitiesIndividualWorld(AZ::Vector3::CreateOne());
+                CopyScaleToSelectedEntitiesIndividualWorld(1.0f);
                 break;
             case Mode::Translation:
                 // do nothing
@@ -2934,7 +2933,7 @@ namespace AzToolsFramework
         }
     }
 
-    void EditorTransformComponentSelection::CopyScaleToSelectedEntitiesIndividualWorld(const AZ::Vector3& scale)
+    void EditorTransformComponentSelection::CopyScaleToSelectedEntitiesIndividualWorld(float scale)
     {
         AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
 
@@ -2949,7 +2948,7 @@ namespace AzToolsFramework
         const auto transformsBefore = RecordTransformsBefore(manipulatorEntityIds.m_entityIds);
 
         // update scale relative to initial
-        const AZ::Transform scaleTransform = AZ::Transform::CreateScale(scale);
+        const AZ::Transform scaleTransform = AZ::Transform::CreateUniformScale(scale);
         for (AZ::EntityId entityId : manipulatorEntityIds.m_entityIds)
         {
             ScopedUndoBatch::MarkEntityDirty(entityId);
@@ -2968,7 +2967,7 @@ namespace AzToolsFramework
         RefreshUiAfterChange(manipulatorEntityIds.m_entityIds);
     }
 
-    void EditorTransformComponentSelection::CopyScaleToSelectedEntitiesIndividualLocal(const AZ::Vector3& scale)
+    void EditorTransformComponentSelection::CopyScaleToSelectedEntitiesIndividualLocal(float scale)
     {
         AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
 
@@ -3014,9 +3013,9 @@ namespace AzToolsFramework
                 if (transformIt != transformsBefore.end())
                 {
                     AZ::Transform newWorldFromLocal = transformIt->second;
-                    const AZ::Vector3 scale = newWorldFromLocal.GetScale();
+                    const float scale = newWorldFromLocal.GetUniformScale();
                     newWorldFromLocal.SetRotation(orientation);
-                    newWorldFromLocal *= AZ::Transform::CreateScale(scale);
+                    newWorldFromLocal *= AZ::Transform::CreateUniformScale(scale);
 
                     SetEntityWorldTransform(entityId, newWorldFromLocal);
                 }
@@ -3661,7 +3660,7 @@ namespace AzToolsFramework
     }
 
     void EditorTransformComponentSelection::SetEntityLocalScale(
-        const AZ::EntityId entityId, const AZ::Vector3& localScale)
+        const AZ::EntityId entityId, const float localScale)
     {
         ETCS::SetEntityLocalScale(entityId, localScale, m_transformChangedInternally);
     }
@@ -3714,11 +3713,11 @@ namespace AzToolsFramework
                 entityId, &AZ::TransformBus::Events::SetWorldTM, worldTransform);
         }
 
-        void SetEntityLocalScale(AZ::EntityId entityId, const AZ::Vector3& localScale, bool& internal)
+        void SetEntityLocalScale(AZ::EntityId entityId, float localScale, bool& internal)
         {
             ScopeSwitch sw(internal);
             AZ::TransformBus::Event(
-                entityId, &AZ::TransformBus::Events::SetLocalScale, localScale);
+                entityId, &AZ::TransformBus::Events::SetLocalUniformScale, localScale);
         }
 
         void SetEntityLocalRotation(AZ::EntityId entityId, const AZ::Vector3& localRotation, bool& internal)
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.h
index 99265313fe..9fd16a6e21 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.h
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.h
@@ -212,8 +212,8 @@ namespace AzToolsFramework
         void CopyOrientationToSelectedEntitiesIndividual(const AZ::Quaternion& orientation);
         void CopyOrientationToSelectedEntitiesGroup(const AZ::Quaternion& orientation);
         void ResetOrientationForSelectedEntitiesLocal();
-        void CopyScaleToSelectedEntitiesIndividualLocal(const AZ::Vector3& scale);
-        void CopyScaleToSelectedEntitiesIndividualWorld(const AZ::Vector3& scale);
+        void CopyScaleToSelectedEntitiesIndividualLocal(float scale);
+        void CopyScaleToSelectedEntitiesIndividualWorld(float scale);
 
         // EditorManipulatorCommandUndoRedoRequestBus ...
         void UndoRedoEntityManipulatorCommand(
@@ -248,7 +248,7 @@ namespace AzToolsFramework
         void SetEntityWorldTranslation(AZ::EntityId entityId, const AZ::Vector3& worldTranslation);
         void SetEntityLocalTranslation(AZ::EntityId entityId, const AZ::Vector3& localTranslation);
         void SetEntityWorldTransform(AZ::EntityId entityId, const AZ::Transform& worldTransform);
-        void SetEntityLocalScale(AZ::EntityId entityId, const AZ::Vector3& localScale);
+        void SetEntityLocalScale(AZ::EntityId entityId, float localScale);
         void SetEntityLocalRotation(AZ::EntityId entityId, const AZ::Vector3& localRotation);
 
         AZ::EntityId m_hoveredEntityId; ///< What EntityId is the mouse currently hovering over (if any).
@@ -316,7 +316,7 @@ namespace AzToolsFramework
         void SetEntityWorldTranslation(AZ::EntityId entityId, const AZ::Vector3& worldTranslation, bool& internal);
         void SetEntityLocalTranslation(AZ::EntityId entityId, const AZ::Vector3& localTranslation, bool& internal);
         void SetEntityWorldTransform(AZ::EntityId entityId, const AZ::Transform& worldTransform, bool& internal);
-        void SetEntityLocalScale(AZ::EntityId entityId, const AZ::Vector3& localScale, bool& internal);
+        void SetEntityLocalScale(AZ::EntityId entityId, float localScale, bool& internal);
         void SetEntityLocalRotation(AZ::EntityId entityId, const AZ::Vector3& localRotation, bool& internal);
     } // namespace ETCS
 } // namespace AzToolsFramework
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelectionRequestBus.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelectionRequestBus.h
index 59c250b8f7..9cd78f8c50 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelectionRequestBus.h
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelectionRequestBus.h
@@ -101,10 +101,10 @@ namespace AzToolsFramework
         virtual void ResetOrientationForSelectedEntitiesLocal() = 0;
 
         /// Copy scale to each individual entity in local space without moving position.
-        virtual void CopyScaleToSelectedEntitiesIndividualLocal(const AZ::Vector3& scale) = 0;
+        virtual void CopyScaleToSelectedEntitiesIndividualLocal(float scale) = 0;
 
         /// Copy scale to to each individual entity in world (absolute) space.
-        virtual void CopyScaleToSelectedEntitiesIndividualWorld(const AZ::Vector3& scale) = 0;
+        virtual void CopyScaleToSelectedEntitiesIndividualWorld(float scale) = 0;
 
     protected:
         ~EditorTransformComponentSelectionRequests() = default;
diff --git a/Code/Framework/GridMate/GridMate/Serialize/CompressionMarshal.cpp b/Code/Framework/GridMate/GridMate/Serialize/CompressionMarshal.cpp
index 751e151ec6..9dc7de1cf7 100644
--- a/Code/Framework/GridMate/GridMate/Serialize/CompressionMarshal.cpp
+++ b/Code/Framework/GridMate/GridMate/Serialize/CompressionMarshal.cpp
@@ -488,18 +488,17 @@ void TransformCompressor::Marshal(WriteBuffer& wb, const AZ::Transform& value) c
 {
     AZ::u8 flags = 0;
     auto flagsMarker = wb.InsertMarker(flags);
-    AZ::Matrix3x3 m33 = AZ::Matrix3x3::CreateFromTransform(value);
-    AZ::Vector3 scale = m33.ExtractScale();
-    AZ::Quaternion rot = AZ::Quaternion::CreateFromMatrix3x3(m33.GetOrthogonalized());
+    float scale = value.GetUniformScale();
+    AZ::Quaternion rot = value.GetRotation();
     if (!rot.IsIdentity())
     {
         flags |= HAS_ROT;
         wb.Write(rot, QuatCompMarshaler());
     }
-    if (!scale.IsClose(AZ::Vector3::CreateOne()))
+    if (!AZ::IsClose(scale, 1.0f))
     {
         flags |= HAS_SCALE;
-        wb.Write(scale, Vec3CompMarshaler());
+        wb.Write(scale, HalfMarshaler());
     }
     AZ::Vector3 pos = value.GetTranslation();
     if (!pos.IsZero())
@@ -527,9 +526,9 @@ void TransformCompressor::Unmarshal(AZ::Transform& value, ReadBuffer& rb) const
     }
     if (flags & HAS_SCALE)
     {
-        AZ::Vector3 scale;
-        rb.Read(scale, Vec3CompMarshaler());
-        xform.MultiplyByScale(scale);
+        float scale;
+        rb.Read(scale, HalfMarshaler());
+        xform.MultiplyByUniformScale(scale);
     }
     if (flags & HAS_POS)
     {
diff --git a/Code/Framework/Tests/TransformComponent.cpp b/Code/Framework/Tests/TransformComponent.cpp
index 44008686cd..0b6110e3aa 100644
--- a/Code/Framework/Tests/TransformComponent.cpp
+++ b/Code/Framework/Tests/TransformComponent.cpp
@@ -24,6 +24,8 @@
 #include <AzToolsFramework/Application/ToolsApplication.h>
 #include <AzToolsFramework/ToolsComponents/TransformComponent.h>
 
+#include <AZTestShared/Math/MathTestHelpers.h>
+
 using namespace AZ;
 using namespace AzFramework;
 
@@ -362,8 +364,8 @@ namespace UnitTest
     TEST_F(TransformComponentTransformMatrixSetGet, SetLocalRotation_SimpleValues_Set)
     {
         // add some scale first
-        float sx = 1.03f, sy = 0.67f, sz = 1.23f;
-        Transform tm = Transform::CreateScale(Vector3(sx, sy, sz));
+        float scale = 1.23f;
+        Transform tm = Transform::CreateUniformScale(scale);
         TransformBus::Event(m_childId, &TransformBus::Events::SetLocalTM, tm);
 
         float rx = 42.435f;
@@ -379,13 +381,13 @@ namespace UnitTest
         Matrix3x3 finalRotate = rotateX * rotateY * rotateZ;
 
         Vector3 basisX = tm.GetBasisX();
-        Vector3 expectedBasisX = finalRotate.GetBasisX() * sx;
+        Vector3 expectedBasisX = finalRotate.GetBasisX() * scale;
         EXPECT_TRUE(basisX.IsClose(expectedBasisX));
         Vector3 basisY = tm.GetBasisY();
-        Vector3 expectedBasisY = finalRotate.GetBasisY() * sy;
+        Vector3 expectedBasisY = finalRotate.GetBasisY() * scale;
         EXPECT_TRUE(basisY.IsClose(expectedBasisY));
         Vector3 basisZ = tm.GetBasisZ();
-        Vector3 expectedBasisZ = finalRotate.GetBasisZ() * sz;
+        Vector3 expectedBasisZ = finalRotate.GetBasisZ() * scale;
         EXPECT_TRUE(basisZ.IsClose(expectedBasisZ));
     }
 
@@ -476,18 +478,15 @@ namespace UnitTest
         {
             TransformBus::Event(m_childId, &TransformBus::Events::RotateAroundLocalX, rx);
         }
-        Vector3 localScale;
-        TransformBus::EventResult(localScale, m_childId, &TransformBus::Events::GetLocalScale);
-        EXPECT_TRUE(localScale.IsClose(Vector3(1.0f, 1.0f, 1.0f)));
+        float localScale = FLT_MAX;
+        TransformBus::EventResult(localScale, m_childId, &TransformBus::Events::GetLocalUniformScale);
+        EXPECT_NEAR(localScale, 1.0f, AZ::Constants::Tolerance);
     }
 
     TEST_F(TransformComponentTransformMatrixSetGet, RotateAroundLocalX_ScaleDoesNotSkewRotation)
     {
-        float sx = 42.564f;
-        float sy = 12.460f;
-        float sz = 28.692f;
-        Vector3 expectedScales(sx, sy, sz);
-        TransformBus::Event(m_childId, &TransformBus::Events::SetLocalScale, expectedScales);
+        float expectedScale = 42.564f;
+        TransformBus::Event(m_childId, &TransformBus::Events::SetLocalUniformScale, expectedScale);
 
         float rx = 1.43f;
         TransformBus::Event(m_childId, &TransformBus::Events::RotateAroundLocalX, rx);
@@ -513,18 +512,15 @@ namespace UnitTest
         {
             TransformBus::Event(m_childId, &TransformBus::Events::RotateAroundLocalY, ry);
         }
-        Vector3 localScale;
-        TransformBus::EventResult(localScale, m_childId, &TransformBus::Events::GetLocalScale);
-        EXPECT_TRUE(localScale.IsClose(Vector3(1.0f, 1.0f, 1.0f)));
+        float localScale = FLT_MAX;
+        TransformBus::EventResult(localScale, m_childId, &TransformBus::Events::GetLocalUniformScale);
+        EXPECT_NEAR(localScale, 1.0f, AZ::Constants::Tolerance);
     }
 
     TEST_F(TransformComponentTransformMatrixSetGet, RotateAroundLocalY_ScaleDoesNotSkewRotation)
     {
-        float sx = 42.564f;
-        float sy = 12.460f;
-        float sz = 28.692f;
-        Vector3 expectedScales(sx, sy, sz);
-        TransformBus::Event(m_childId, &TransformBus::Events::SetLocalScale, expectedScales);
+        float expectedScale = 42.564f;
+        TransformBus::Event(m_childId, &TransformBus::Events::SetLocalUniformScale, expectedScale);
 
         float ry = 1.43f;
         TransformBus::Event(m_childId, &TransformBus::Events::RotateAroundLocalY, ry);
@@ -550,18 +546,15 @@ namespace UnitTest
         {
             TransformBus::Event(m_childId, &TransformBus::Events::RotateAroundLocalZ, rz);
         }
-        Vector3 localScale;
-        TransformBus::EventResult(localScale, m_childId, &TransformBus::Events::GetLocalScale);
-        EXPECT_TRUE(localScale.IsClose(Vector3(1.0f, 1.0f, 1.0f)));
+        float localScale = FLT_MAX;
+        TransformBus::EventResult(localScale, m_childId, &TransformBus::Events::GetLocalUniformScale);
+        EXPECT_NEAR(localScale, 1.0f, AZ::Constants::Tolerance);
     }
 
     TEST_F(TransformComponentTransformMatrixSetGet, RotateAroundLocalZ_ScaleDoesNotSkewRotation)
     {
-        float sx = 42.564f;
-        float sy = 12.460f;
-        float sz = 28.692f;
-        Vector3 expectedScales(sx, sy, sz);
-        TransformBus::Event(m_childId, &TransformBus::Events::SetLocalScale, expectedScales);
+        float expectedScale = 42.564f;
+        TransformBus::Event(m_childId, &TransformBus::Events::SetLocalUniformScale, expectedScale);
 
         float rz = 1.43f;
         TransformBus::Event(m_childId, &TransformBus::Events::RotateAroundLocalZ, rz);
@@ -572,65 +565,50 @@ namespace UnitTest
 
     TEST_F(TransformComponentTransformMatrixSetGet, SetLocalScale_SimpleValues_Set)
     {
-        float sx = 42.564f;
-        float sy = 12.460f;
-        float sz = 28.692f;
-        Vector3 expectedScales(sx, sy, sz);
-        TransformBus::Event(m_childId, &TransformBus::Events::SetLocalScale, expectedScales);
+        float expectedScale = 42.564f;
+        TransformBus::Event(m_childId, &TransformBus::Events::SetLocalUniformScale, expectedScale);
 
-        Transform tm ;
+        Transform tm;
         TransformBus::EventResult(tm, m_childId, &TransformBus::Events::GetLocalTM);
-        Vector3 scales = tm.GetScale();
-        EXPECT_TRUE(scales.IsClose(expectedScales));
+        float scale = tm.GetUniformScale();
+        EXPECT_NEAR(scale, expectedScale, AZ::Constants::Tolerance);
     }
 
     TEST_F(TransformComponentTransformMatrixSetGet, GetLocalScale_SimpleValues_Return)
     {
-        float sx = 43.463f;
-        float sy = 346.22f;
-        float sz = 863.32f;
-        Vector3 expectedScales(sx, sy, sz);
-        Transform scaleTM = Transform::CreateScale(expectedScales);
+        float expectedScale = 43.463f;
+        Transform scaleTM = Transform::CreateUniformScale(expectedScale);
         TransformBus::Event(m_childId, &TransformBus::Events::SetLocalTM, scaleTM);
 
-        Vector3 scales;
-        TransformBus::EventResult(scales, m_childId, &TransformBus::Events::GetLocalScale);
-        EXPECT_TRUE(scales.IsClose(expectedScales));
+        float scale;
+        TransformBus::EventResult(scale, m_childId, &TransformBus::Events::GetLocalUniformScale);
+        EXPECT_NEAR(scale, expectedScale, AZ::Constants::Tolerance);
     }
 
     TEST_F(TransformComponentTransformMatrixSetGet, GetWorldScale_ChildHasNoScale_ReturnScaleSameAsParent)
     {
-        float sx = 43.463f;
-        float sy = 346.22f;
-        float sz = 863.32f;
-        Vector3 expectedScales(sx, sy, sz);
-        Transform scaleTM = Transform::CreateScale(expectedScales);
+        float expectedScale = 43.463f;
+        Transform scaleTM = Transform::CreateUniformScale(expectedScale);
         TransformBus::Event(m_parentId, &TransformBus::Events::SetLocalTM, scaleTM);
 
-        Vector3 scales;
-        TransformBus::EventResult(scales, m_childId, &TransformBus::Events::GetWorldScale);
-        EXPECT_TRUE(scales.IsClose(expectedScales));
+        float scale = FLT_MAX;
+        TransformBus::EventResult(scale, m_childId, &TransformBus::Events::GetWorldUniformScale);
+        EXPECT_NEAR(scale, expectedScale, AZ::Constants::Tolerance);
     }
 
     TEST_F(TransformComponentTransformMatrixSetGet, GetWorldScale_ChildHasScale_ReturnCompoundScale)
     {
-        float sx = 4.463f;
-        float sy = 3.22f;
-        float sz = 8.32f;
-        Vector3 parentScales(sx, sy, sz);
-        Transform parentScaleTM = Transform::CreateScale(parentScales);
+        float parentScale = 4.463f;
+        Transform parentScaleTM = Transform::CreateUniformScale(parentScale);
         TransformBus::Event(m_parentId, &TransformBus::Events::SetLocalTM, parentScaleTM);
 
-        float csx = 1.64f;
-        float csy = 9.35f;
-        float csz = 1.57f;
-        Vector3 childScales(csx, csy, csz);
-        Transform childScaleTM = Transform::CreateScale(childScales);
+        float childScale = 1.64f;
+        Transform childScaleTM = Transform::CreateUniformScale(childScale);
         TransformBus::Event(m_childId, &TransformBus::Events::SetLocalTM, childScaleTM);
 
-        Vector3 scales;
-        TransformBus::EventResult(scales, m_childId, &TransformBus::Events::GetWorldScale);
-        EXPECT_TRUE(scales.IsClose(parentScales * childScales));
+        float scale = FLT_MAX;
+        TransformBus::EventResult(scale, m_childId, &TransformBus::Events::GetWorldUniformScale);
+        EXPECT_NEAR(scale, parentScale * childScale, AZ::Constants::Tolerance);
     }
 
     class TransformComponentHierarchy
diff --git a/Code/Sandbox/Editor/Objects/SelectionGroup.cpp b/Code/Sandbox/Editor/Objects/SelectionGroup.cpp
index b883b78e49..6363257e2f 100644
--- a/Code/Sandbox/Editor/Objects/SelectionGroup.cpp
+++ b/Code/Sandbox/Editor/Objects/SelectionGroup.cpp
@@ -490,28 +490,6 @@ void CSelectionGroup::StartScaling()
 }
 
 
-void CSelectionGroup::FinishScaling(const Vec3& scale, [[maybe_unused]] int referenceCoordSys)
-{
-    if (fabs(scale.x - scale.y) < 0.001f &&
-        fabs(scale.y - scale.z) < 0.001f &&
-        fabs(scale.z - scale.x) < 0.001f)
-    {
-        return;
-    }
-
-    for (int i = 0; i < GetFilteredCount(); ++i)
-    {
-        CBaseObject* obj = GetFilteredObject(i);
-        Vec3 OriginalScale;
-        if (obj->GetUntransformedScale(OriginalScale))
-        {
-            obj->TransformScale(scale);
-            obj->SetScale(OriginalScale);
-        }
-    }
-}
-
-
 //////////////////////////////////////////////////////////////////////////
 void CSelectionGroup::Align()
 {
diff --git a/Code/Sandbox/Editor/Objects/SelectionGroup.h b/Code/Sandbox/Editor/Objects/SelectionGroup.h
index 277ff2a492..9f672f28b2 100644
--- a/Code/Sandbox/Editor/Objects/SelectionGroup.h
+++ b/Code/Sandbox/Editor/Objects/SelectionGroup.h
@@ -103,7 +103,6 @@ public:
     void StartScaling();
     void Scale(const Vec3& scale, int referenceCoordSys);
     void SetScale(const Vec3& scale, int referenceCoordSys);
-    void FinishScaling(const Vec3& scale, int referenceCoordSys);
     //! Align objects in selection to surface normal
     void Align();
     //! Very special method to move contents of a voxel.
diff --git a/Code/Sandbox/Editor/TrackView/TrackViewAnimNode.cpp b/Code/Sandbox/Editor/TrackView/TrackViewAnimNode.cpp
index ae7077b4fc..b9814e66c1 100644
--- a/Code/Sandbox/Editor/TrackView/TrackViewAnimNode.cpp
+++ b/Code/Sandbox/Editor/TrackView/TrackViewAnimNode.cpp
@@ -1869,7 +1869,7 @@ void CTrackViewAnimNode::SetPos(const Vec3& position)
 }
 
 //////////////////////////////////////////////////////////////////////////
-void CTrackViewAnimNode::SetScale(const Vec3& scale)
+void CTrackViewAnimNode::SetScale(float scale)
 {
     CTrackViewTrack* track = GetTrackForParameter(AnimParamType::Scale);
 
@@ -2012,9 +2012,9 @@ void CTrackViewAnimNode::SetPosRotScaleTracksDefaultValues(bool positionAllowed,
             }
             if (scaleAllowed)
             {
-                AZ::Vector3 scale = AZ::Vector3::CreateOne();
-                AZ::TransformBus::EventResult(scale, entityId, &AZ::TransformBus::Events::GetWorldScale);
-                m_animNode->SetScale(time, AZVec3ToLYVec3(scale));
+                float scale = 1.0f;
+                AZ::TransformBus::EventResult(scale, entityId, &AZ::TransformBus::Events::GetWorldUniformScale);
+                m_animNode->SetScale(time, scale);
             }
         }
     }
@@ -2482,11 +2482,11 @@ Quat CTrackViewAnimNode::GetTransformDelegateRotation(const Quat& baseRotation)
 //////////////////////////////////////////////////////////////////////////
 Vec3 CTrackViewAnimNode::GetTransformDelegateScale(const Vec3& baseScale) const
 {
-    const Vec3 scale = GetScale();
+     float scale = GetScale();
 
-    return Vec3(CheckTrackAnimated(AnimParamType::ScaleX) ? scale.x : baseScale.x,
-        CheckTrackAnimated(AnimParamType::ScaleY) ? scale.y : baseScale.y,
-        CheckTrackAnimated(AnimParamType::ScaleZ) ? scale.z : baseScale.z);
+     return Vec3(CheckTrackAnimated(AnimParamType::ScaleX) ? scale : baseScale.x,
+         CheckTrackAnimated(AnimParamType::ScaleY) ? scale : baseScale.y,
+         CheckTrackAnimated(AnimParamType::ScaleZ) ? scale : baseScale.z);
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -2504,7 +2504,7 @@ void CTrackViewAnimNode::SetTransformDelegateRotation(const Quat& rotation)
 //////////////////////////////////////////////////////////////////////////
 void CTrackViewAnimNode::SetTransformDelegateScale(const Vec3& scale)
 {
-    SetScale(scale);
+    SetScale(scale.x);
 }
 
 bool CTrackViewAnimNode::IsTransformAnimParamTypeDelegated(const AnimParamType animParamType) const
diff --git a/Code/Sandbox/Editor/TrackView/TrackViewAnimNode.h b/Code/Sandbox/Editor/TrackView/TrackViewAnimNode.h
index 1e0cc2262a..4435d0efc7 100644
--- a/Code/Sandbox/Editor/TrackView/TrackViewAnimNode.h
+++ b/Code/Sandbox/Editor/TrackView/TrackViewAnimNode.h
@@ -182,8 +182,8 @@ public:
     // Rotation/Position & Scale
     void SetPos(const Vec3& position);
     Vec3 GetPos() const { return m_animNode->GetPos(); }
-    void SetScale(const Vec3& scale);
-    Vec3 GetScale() const { return m_animNode->GetScale(); }
+    void SetScale(float scale);
+    float GetScale() const { return m_animNode->GetScale(); }
     void SetRotation(const Quat& rotation);
     Quat GetRotation() const { return m_animNode->GetRotate(); }
     Quat GetRotation(float time) const { return m_animNode != nullptr ? m_animNode->GetRotate(time) : Quat(0,0,0,0); }
diff --git a/Code/Sandbox/Editor/TrackView/TrackViewSequence.cpp b/Code/Sandbox/Editor/TrackView/TrackViewSequence.cpp
index f915c804f8..3642f21da6 100644
--- a/Code/Sandbox/Editor/TrackView/TrackViewSequence.cpp
+++ b/Code/Sandbox/Editor/TrackView/TrackViewSequence.cpp
@@ -825,10 +825,10 @@ void CTrackViewSequence::SyncSelectedTracksToBase()
                 {
                     const Vec3 position = pAnimNode->GetPos();
                     const Quat rotation = pAnimNode->GetRotation();
-                    const Vec3 scale = pAnimNode->GetScale();
+                    const float scale = pAnimNode->GetScale();
 
                     AZ::Transform transform = AZ::Transform::CreateIdentity();
-                    transform.SetScale(LYVec3ToAZVec3(scale));
+                    transform.SetUniformScale(scale);
                     transform.SetRotation(LYQuaternionToAZQuaternion(rotation));
                     transform.SetTranslation(LYVec3ToAZVec3(position));
 
@@ -870,7 +870,7 @@ void CTrackViewSequence::SyncSelectedTracksFromBase()
 
                 pAnimNode->SetPos(AZVec3ToLYVec3(transform.GetTranslation()));
                 pAnimNode->SetRotation(AZQuaternionToLYQuaternion(transform.GetRotation()));
-                pAnimNode->SetScale(AZVec3ToLYVec3(transform.GetScale()));
+                pAnimNode->SetScale(transform.GetUniformScale());
 
                 bNothingWasSynced = false;
             }
diff --git a/Code/Tools/SceneAPI/SceneCore/Containers/Utilities/SceneUtilities.cpp b/Code/Tools/SceneAPI/SceneCore/Containers/Utilities/SceneUtilities.cpp
index f5bb9d28a6..ac27ed54eb 100644
--- a/Code/Tools/SceneAPI/SceneCore/Containers/Utilities/SceneUtilities.cpp
+++ b/Code/Tools/SceneAPI/SceneCore/Containers/Utilities/SceneUtilities.cpp
@@ -79,7 +79,7 @@ namespace AZ
                     if (coordinateSystemRule->GetScale() != 1.0f)
                     {
                         float scale = coordinateSystemRule->GetScale();
-                        matrix.MultiplyByScale(Vector3(scale, scale, scale));
+                        matrix.MultiplyByScale(Vector3(scale));
                     }
                     if (!coordinateSystemRule->GetOriginNodeName().empty())
                     {
diff --git a/Code/Tools/SceneAPI/SceneUI/RowWidgets/TransformRowHandler.cpp b/Code/Tools/SceneAPI/SceneUI/RowWidgets/TransformRowHandler.cpp
index 09588a606e..640c092070 100644
--- a/Code/Tools/SceneAPI/SceneUI/RowWidgets/TransformRowHandler.cpp
+++ b/Code/Tools/SceneAPI/SceneUI/RowWidgets/TransformRowHandler.cpp
@@ -13,6 +13,7 @@
 #include <AzCore/EBus/EBus.h>
 #include <AzToolsFramework/Debug/TraceContext.h>
 #include <AzToolsFramework/UI/PropertyEditor/PropertyVectorCtrl.hxx>
+#include <AzToolsFramework/UI/PropertyEditor/PropertyDoubleSpinCtrl.hxx>
 #include <SceneAPI/SceneUI/RowWidgets/TransformRowHandler.h>
 
 namespace AZ
@@ -58,10 +59,11 @@ namespace AZ
                 }
                 else
                 {
-                    AzToolsFramework::Vector3PropertyHandler handler;
-                    handler.ConsumeAttribute(widget->GetTranslationWidget(), attrib, attrValue, debugName);
-                    handler.ConsumeAttribute(widget->GetRotationWidget(), attrib, attrValue, debugName);
-                    handler.ConsumeAttribute(widget->GetScaleWidget(), attrib, attrValue, debugName);
+                    AzToolsFramework::Vector3PropertyHandler vector3Handler;
+                    vector3Handler.ConsumeAttribute(widget->GetTranslationWidget(), attrib, attrValue, debugName);
+                    vector3Handler.ConsumeAttribute(widget->GetRotationWidget(), attrib, attrValue, debugName);
+                    AzToolsFramework::doublePropertySpinboxHandler spinboxHandler;
+                    spinboxHandler.ConsumeAttribute(widget->GetScaleWidget(), attrib, attrValue, debugName);
                 }
             }
 
@@ -109,4 +111,4 @@ namespace AZ
     } // namespace SceneAPI
 } // namespace AZ
 
-#include <RowWidgets/moc_TransformRowHandler.cpp>
\ No newline at end of file
+#include <RowWidgets/moc_TransformRowHandler.cpp>
diff --git a/Code/Tools/SceneAPI/SceneUI/RowWidgets/TransformRowHandler.h b/Code/Tools/SceneAPI/SceneUI/RowWidgets/TransformRowHandler.h
index a020ee8198..582f32649e 100644
--- a/Code/Tools/SceneAPI/SceneUI/RowWidgets/TransformRowHandler.h
+++ b/Code/Tools/SceneAPI/SceneUI/RowWidgets/TransformRowHandler.h
@@ -60,4 +60,4 @@ namespace AZ
             };
         } // namespace SceneUI
     } // namespace SceneAPI
-} // namespace AZ
\ No newline at end of file
+} // namespace AZ
diff --git a/Code/Tools/SceneAPI/SceneUI/RowWidgets/TransformRowWidget.cpp b/Code/Tools/SceneAPI/SceneUI/RowWidgets/TransformRowWidget.cpp
index 10e0fd2a68..e8ecaa0c27 100644
--- a/Code/Tools/SceneAPI/SceneUI/RowWidgets/TransformRowWidget.cpp
+++ b/Code/Tools/SceneAPI/SceneUI/RowWidgets/TransformRowWidget.cpp
@@ -15,6 +15,7 @@
 #include <QGridLayout>
 #include <SceneAPI/SceneUI/RowWidgets/TransformRowWidget.h>
 #include <AzQtComponents/Components/Widgets/VectorInput.h>
+#include <AzToolsFramework/UI/PropertyEditor/PropertyDoubleSpinCtrl.hxx>
 #include <AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI.h>
 #include <AzToolsFramework/UI/PropertyEditor/PropertyRowWidget.hxx>
 
@@ -47,7 +48,7 @@ namespace AZ
             ExpandedTransform::ExpandedTransform()
                 : m_translation(0, 0, 0)
                 , m_rotation(0, 0, 0)
-                , m_scale(1, 1, 1)
+                , m_scale(1)
             {
             }
 
@@ -60,14 +61,14 @@ namespace AZ
             {
                 m_translation = transform.GetTranslation();
                 m_rotation = transform.GetEulerDegrees();
-                m_scale = transform.GetScale();
+                m_scale = transform.GetUniformScale();
             }
 
             void ExpandedTransform::GetTransform(AZ::Transform& transform) const
             {
                 transform = Transform::CreateTranslation(m_translation);
                 transform *= AZ::ConvertEulerDegreesToTransform(m_rotation);
-                transform.MultiplyByScale(m_scale);
+                transform.MultiplyByUniformScale(m_scale);
             }
 
             const AZ::Vector3& ExpandedTransform::GetTranslation() const
@@ -90,12 +91,12 @@ namespace AZ
                 m_rotation = rotation;
             }
 
-            const AZ::Vector3& ExpandedTransform::GetScale() const
+            const float ExpandedTransform::GetScale() const
             {
                 return m_scale;
             }
 
-            void ExpandedTransform::SetScale(const AZ::Vector3& scale)
+            void ExpandedTransform::SetScale(const float scale)
             {
                 m_scale = scale;
             }
@@ -131,7 +132,7 @@ namespace AZ
                 m_rotationWidget->setMaximum(360);
                 m_rotationWidget->setSuffix(" degrees");
 
-                m_scaleWidget = new AzQtComponents::VectorInput(this, 3);
+                m_scaleWidget = new AzToolsFramework::PropertyDoubleSpinCtrl(this);
                 m_scaleWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
                 m_scaleWidget->setMinimum(0);
                 m_scaleWidget->setMaximum(10000);
@@ -191,13 +192,10 @@ namespace AZ
                     AzToolsFramework::PropertyEditorGUIMessages::Bus::Broadcast(&AzToolsFramework::PropertyEditorGUIMessages::RequestWrite, this);
                 });
 
-                QObject::connect(m_scaleWidget, &AzQtComponents::VectorInput::valueChanged, this, [this]
+                QObject::connect(m_scaleWidget, &AzToolsFramework::PropertyDoubleSpinCtrl::valueChanged, this, [this]
                 {
-                    AzQtComponents::VectorInput* widget = this->GetScaleWidget();
-                    AZ::Vector3 scale;
-
-                    PopulateVector3(widget, scale);
-
+                    AzToolsFramework::PropertyDoubleSpinCtrl* widget = this->GetScaleWidget();
+                    float scale = aznumeric_cast<float>(widget->value());
                     m_transform.SetScale(scale);
                     AzToolsFramework::PropertyEditorGUIMessages::Bus::Broadcast(&AzToolsFramework::PropertyEditorGUIMessages::RequestWrite, this);
                 });
@@ -224,9 +222,7 @@ namespace AZ
                 m_rotationWidget->setValuebyIndex(m_transform.GetRotation().GetY(), 1);
                 m_rotationWidget->setValuebyIndex(m_transform.GetRotation().GetZ(), 2);
 
-                m_scaleWidget->setValuebyIndex(m_transform.GetScale().GetX(), 0);
-                m_scaleWidget->setValuebyIndex(m_transform.GetScale().GetY(), 1);
-                m_scaleWidget->setValuebyIndex(m_transform.GetScale().GetZ(), 2);
+                m_scaleWidget->setValue(m_transform.GetScale());
 
                 blockSignals(false);
             }
@@ -251,7 +247,7 @@ namespace AZ
                 return m_rotationWidget;
             }
 
-            AzQtComponents::VectorInput* TransformRowWidget::GetScaleWidget()
+            AzToolsFramework::PropertyDoubleSpinCtrl* TransformRowWidget::GetScaleWidget()
             {
                 return m_scaleWidget;
             }
diff --git a/Code/Tools/SceneAPI/SceneUI/RowWidgets/TransformRowWidget.h b/Code/Tools/SceneAPI/SceneUI/RowWidgets/TransformRowWidget.h
index dc3286f80e..3977d26c7c 100644
--- a/Code/Tools/SceneAPI/SceneUI/RowWidgets/TransformRowWidget.h
+++ b/Code/Tools/SceneAPI/SceneUI/RowWidgets/TransformRowWidget.h
@@ -21,6 +21,7 @@
 #include <AzCore/Math/Uuid.h>
 #include <AzCore/Memory/SystemAllocator.h>
 #include <SceneAPI/SceneUI/SceneUIConfiguration.h>
+
 #endif
 
 namespace AzQtComponents
@@ -28,6 +29,11 @@ namespace AzQtComponents
     class VectorInput;
 }
 
+namespace AzToolsFramework
+{
+    class PropertyDoubleSpinCtrl;
+}
+
 namespace AZ
 {
     namespace SceneAPI
@@ -51,14 +57,14 @@ namespace AZ
                 const AZ::Vector3& GetRotation() const;
                 void SetRotation(const AZ::Vector3& translation);
 
-                const AZ::Vector3& GetScale() const;
-                void SetScale(const AZ::Vector3& scale);
+                const float GetScale() const;
+                void SetScale(const float scale);
 
             private:
                 AZ_PUSH_DISABLE_DLL_EXPORT_MEMBER_WARNING
                 AZ::Vector3 m_translation;
                 AZ::Vector3 m_rotation;
-                AZ::Vector3 m_scale;
+                float m_scale;
                 AZ_POP_DISABLE_DLL_EXPORT_MEMBER_WARNING
             };
 
@@ -78,7 +84,7 @@ namespace AZ
 
                 AzQtComponents::VectorInput* GetTranslationWidget();
                 AzQtComponents::VectorInput* GetRotationWidget();
-                AzQtComponents::VectorInput* GetScaleWidget();
+                AzToolsFramework::PropertyDoubleSpinCtrl* GetScaleWidget();
 
             protected:
                 ExpandedTransform m_transform;
@@ -87,7 +93,7 @@ namespace AZ
 
                 AzQtComponents::VectorInput* m_translationWidget;
                 AzQtComponents::VectorInput* m_rotationWidget;
-                AzQtComponents::VectorInput* m_scaleWidget;
+                AzToolsFramework::PropertyDoubleSpinCtrl* m_scaleWidget;
             };
         } // namespace SceneUI
     } // namespace SceneAPI
diff --git a/Code/Tools/SceneAPI/SceneUI/Tests/RowWidgets/TransformRowWidgetTests.cpp b/Code/Tools/SceneAPI/SceneUI/Tests/RowWidgets/TransformRowWidgetTests.cpp
index 05082f29fb..cda6582e63 100644
--- a/Code/Tools/SceneAPI/SceneUI/Tests/RowWidgets/TransformRowWidgetTests.cpp
+++ b/Code/Tools/SceneAPI/SceneUI/Tests/RowWidgets/TransformRowWidgetTests.cpp
@@ -30,7 +30,7 @@ namespace AZ
 
                 Vector3 m_translation = Vector3(10.0f, 20.0f, 30.0f);
                 Vector3 m_rotation = Vector3(30.0f, 45.0f, 60.0f);
-                Vector3 m_scale = Vector3(2.0f, 3.0f, 4.0f);
+                float m_scale = 3.0f;
             };
 
             TEST_F(TransformRowWidgetTest, GetTranslation_TranslationInMatrix_TranslationCanBeRetrievedDirectly)
@@ -83,26 +83,22 @@ namespace AZ
 
             TEST_F(TransformRowWidgetTest, GetScale_ScaleInMatrix_ScaleCanBeRetrievedDirectly)
             {
-                m_transform = Transform::CreateScale(m_scale);
+                m_transform = Transform::CreateUniformScale(m_scale);
                 m_expanded.SetTransform(m_transform);
 
-                const Vector3& returned = m_expanded.GetScale();
-                EXPECT_NEAR(m_scale.GetX(), returned.GetX(), 0.1f);
-                EXPECT_NEAR(m_scale.GetY(), returned.GetY(), 0.1f);
-                EXPECT_NEAR(m_scale.GetZ(), returned.GetZ(), 0.1f);
+                const float returned = m_expanded.GetScale();
+                EXPECT_NEAR(m_scale, returned, 0.1f);
             }
 
             TEST_F(TransformRowWidgetTest, GetScale_ScaleInMatrix_ScaleCanBeRetrievedFromTransform)
             {
-                m_transform = Transform::CreateScale(m_scale);
+                m_transform = Transform::CreateUniformScale(m_scale);
                 m_expanded.SetTransform(m_transform);
 
                 Transform rebuild;
                 m_expanded.GetTransform(rebuild);
-                Vector3 returned = rebuild.GetScale();
-                EXPECT_NEAR(m_scale.GetX(), returned.GetX(), 0.1f);
-                EXPECT_NEAR(m_scale.GetY(), returned.GetY(), 0.1f);
-                EXPECT_NEAR(m_scale.GetZ(), returned.GetZ(), 0.1f);
+                float returned = rebuild.GetUniformScale();
+                EXPECT_NEAR(m_scale, returned, 0.1f);
             }
 
             TEST_F(TransformRowWidgetTest, GetTransform_RotateAndTranslateInMatrix_ReconstructedTransformMatchesOriginal)
@@ -121,7 +117,7 @@ namespace AZ
             {
                 Quaternion quaternion = AZ::ConvertEulerDegreesToQuaternion(m_rotation);
                 m_transform = Transform::CreateFromQuaternionAndTranslation(quaternion, m_translation);
-                m_transform.MultiplyByScale(m_scale);
+                m_transform.MultiplyByUniformScale(m_scale);
                 m_expanded.SetTransform(m_transform);
 
                 Transform rebuild;
diff --git a/Gems/Atom/Tools/MaterialEditor/Code/Source/Viewport/MaterialViewportRenderer.cpp b/Gems/Atom/Tools/MaterialEditor/Code/Source/Viewport/MaterialViewportRenderer.cpp
index e1bfaa3872..b55dcf2088 100644
--- a/Gems/Atom/Tools/MaterialEditor/Code/Source/Viewport/MaterialViewportRenderer.cpp
+++ b/Gems/Atom/Tools/MaterialEditor/Code/Source/Viewport/MaterialViewportRenderer.cpp
@@ -16,6 +16,7 @@
 #include <AzCore/Component/Component.h>
 
 #include <AzFramework/Components/TransformComponent.h>
+#include <AzFramework/Components/NonUniformScaleComponent.h>
 #include <AzFramework/Entity/GameEntityContextBus.h>
 
 #include <AtomCore/Instance/InstanceDatabase.h>
@@ -178,9 +179,10 @@ namespace MaterialEditor
         m_shadowCatcherEntity->CreateComponent(AZ::Render::MeshComponentTypeId);
         m_shadowCatcherEntity->CreateComponent(AZ::Render::MaterialComponentTypeId);
         m_shadowCatcherEntity->CreateComponent(azrtti_typeid<AzFramework::TransformComponent>());
+        m_shadowCatcherEntity->CreateComponent(azrtti_typeid<AzFramework::NonUniformScaleComponent>());
         m_shadowCatcherEntity->Activate();
 
-        AZ::TransformBus::Event(m_shadowCatcherEntity->GetId(), &AZ::TransformBus::Events::SetLocalScale, AZ::Vector3{ 100, 100, 1.0 });
+        AZ::NonUniformScaleRequestBus::Event(m_shadowCatcherEntity->GetId(), &AZ::NonUniformScaleRequests::SetScale, AZ::Vector3{ 100, 100, 1.0 });
 
         AZ::Data::AssetId shadowCatcherModelAssetId = RPI::AssetUtils::GetAssetIdForProductPath("materialeditor/viewportmodels/plane_1x1.azmodel", RPI::AssetUtils::TraceLevel::Error);
         AZ::Render::MeshComponentRequestBus::Event(m_shadowCatcherEntity->GetId(),
diff --git a/Gems/AtomLyIntegration/CommonFeatures/Code/Source/CoreLights/PolygonLightDelegate.cpp b/Gems/AtomLyIntegration/CommonFeatures/Code/Source/CoreLights/PolygonLightDelegate.cpp
index c2bcc566e0..6ec780c2ab 100644
--- a/Gems/AtomLyIntegration/CommonFeatures/Code/Source/CoreLights/PolygonLightDelegate.cpp
+++ b/Gems/AtomLyIntegration/CommonFeatures/Code/Source/CoreLights/PolygonLightDelegate.cpp
@@ -50,7 +50,6 @@ namespace AZ
                 AZStd::vector<Vector2> vertices = m_shapeBus->GetPolygonPrism()->m_vertexContainer.GetVertices();
 
                 Transform transform = GetTransform();
-                transform.SetScale(Vector3(transform.GetScale().GetMaxElement())); // Poly Prism only supports uniform scale, so use max element.
 
                 AZStd::vector<Vector3> transformedVertices;
                 transformedVertices.reserve(vertices.size());
diff --git a/Gems/Blast/Code/Tests/BlastFamilyTest.cpp b/Gems/Blast/Code/Tests/BlastFamilyTest.cpp
index 2e6fd7f2bb..7af9f41e9c 100644
--- a/Gems/Blast/Code/Tests/BlastFamilyTest.cpp
+++ b/Gems/Blast/Code/Tests/BlastFamilyTest.cpp
@@ -137,7 +137,7 @@ namespace Blast
                 .Times(1)
                 .WillOnce(Return(false));
 
-            AZ::Transform transform = AZ::Transform::CreateScale(AZ::Vector3::CreateOne());
+            AZ::Transform transform = AZ::Transform::CreateUniformScale(1.0f);
             blastFamily->Spawn(transform);
         }
 
diff --git a/Gems/Blast/Code/Tests/Mocks/BlastMocks.h b/Gems/Blast/Code/Tests/Mocks/BlastMocks.h
index 88c22cf67f..c9455c2fb3 100644
--- a/Gems/Blast/Code/Tests/Mocks/BlastMocks.h
+++ b/Gems/Blast/Code/Tests/Mocks/BlastMocks.h
@@ -669,6 +669,9 @@ namespace Blast
         MOCK_METHOD1(SetLocalScale, void(const AZ::Vector3&));
         MOCK_METHOD0(GetLocalScale, AZ::Vector3());
         MOCK_METHOD0(GetWorldScale, AZ::Vector3());
+        MOCK_METHOD1(SetLocalUniformScale, void(float));
+        MOCK_METHOD0(GetLocalUniformScale, float());
+        MOCK_METHOD0(GetWorldUniformScale, float());
         MOCK_METHOD0(GetParentId, AZ::EntityId());
         MOCK_METHOD0(GetParent, TransformInterface*());
         MOCK_METHOD1(SetParent, void(AZ::EntityId));
diff --git a/Gems/EMotionFX/Code/EMotionFX/Rendering/Common/RenderUtil.cpp b/Gems/EMotionFX/Code/EMotionFX/Rendering/Common/RenderUtil.cpp
index 0aef3f9d4f..3a23241385 100644
--- a/Gems/EMotionFX/Code/EMotionFX/Rendering/Common/RenderUtil.cpp
+++ b/Gems/EMotionFX/Code/EMotionFX/Rendering/Common/RenderUtil.cpp
@@ -1157,7 +1157,7 @@ namespace MCommon
     void RenderUtil::RenderSphere(const AZ::Vector3& position, float radius, const MCore::RGBAColor& color)
     {
         // setup the world space matrix of the sphere
-        AZ::Transform sphereTransform = AZ::Transform::CreateScale(AZ::Vector3(radius, radius, radius));
+        AZ::Transform sphereTransform = AZ::Transform::CreateUniformScale(radius);
         sphereTransform.SetTranslation(position);
 
         // render the sphere
diff --git a/Gems/GradientSignal/Code/Include/GradientSignal/Util.h b/Gems/GradientSignal/Code/Include/GradientSignal/Util.h
index 4e15bdc293..1a8bb00eba 100644
--- a/Gems/GradientSignal/Code/Include/GradientSignal/Util.h
+++ b/Gems/GradientSignal/Code/Include/GradientSignal/Util.h
@@ -14,6 +14,7 @@
 #include <AzCore/Math/Aabb.h>
 #include <AzCore/Math/Vector3.h>
 #include <AzCore/Component/EntityId.h>
+#include <AzCore/Math/Matrix3x4.h>
 #include <AzCore/Math/Transform.h>
 #include <LmbrCentral/Shape/ShapeComponentBus.h>
 
@@ -64,15 +65,15 @@ namespace GradientSignal
             AZ::LerpInverse(bounds.GetMin().GetZ(), bounds.GetMax().GetZ(), point.GetZ()));
     }
 
-    inline void GetObbParamsFromShape(const AZ::EntityId& entity, AZ::Aabb& bounds, AZ::Transform& worldToBoundsTransform)
+    inline void GetObbParamsFromShape(const AZ::EntityId& entity, AZ::Aabb& bounds, AZ::Matrix3x4& worldToBoundsTransform)
     {
         //get bound and transform data for associated shape
         bounds = AZ::Aabb::CreateNull();
-        worldToBoundsTransform = AZ::Transform::CreateIdentity();
+        AZ::Transform transform = AZ::Transform::CreateIdentity();
         if (entity.IsValid())
         {
-            LmbrCentral::ShapeComponentRequestsBus::Event(entity, &LmbrCentral::ShapeComponentRequestsBus::Events::GetTransformAndLocalBounds, worldToBoundsTransform, bounds);
-            worldToBoundsTransform.Invert();
+            LmbrCentral::ShapeComponentRequestsBus::Event(entity, &LmbrCentral::ShapeComponentRequestsBus::Events::GetTransformAndLocalBounds, transform, bounds);
+            worldToBoundsTransform = AZ::Matrix3x4::CreateFromTransform(transform.GetInverse());
         }
     }
 
diff --git a/Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.cpp b/Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.cpp
index 0b967a6957..6cee088a1c 100644
--- a/Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.cpp
+++ b/Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.cpp
@@ -333,7 +333,7 @@ namespace GradientSignal
         AZStd::lock_guard<decltype(m_cacheMutex)> lock(m_cacheMutex);
 
         //transforming coordinate into "local" relative space of shape bounds
-        outUVW = m_shapeTransformInverse.TransformPoint(inPosition);
+        outUVW = m_shapeTransformInverse * inPosition;
 
         if (!m_configuration.m_advancedMode || !m_configuration.m_is3d)
         {
@@ -387,7 +387,7 @@ namespace GradientSignal
     void GradientTransformComponent::GetGradientEncompassingBounds(AZ::Aabb& bounds) const
     {
         bounds = m_shapeBounds;
-        bounds.ApplyTransform(m_shapeTransformInverse.GetInverse());
+        bounds.ApplyMatrix3x4(m_shapeTransformInverse.GetInverseFull());
     }
 
     void GradientTransformComponent::OnCompositionChanged()
@@ -500,10 +500,11 @@ namespace GradientSignal
         m_shapeBounds = AZ::Aabb::CreateFromMinMax(-m_configuration.m_bounds * 0.5f, m_configuration.m_bounds * 0.5f);
 
         //rebuild transform from parameters
-        AZ::Quaternion rotation;
-        rotation.SetFromEulerDegrees(m_configuration.m_rotate);
-        const AZ::Transform shapeTransformFinal(m_configuration.m_translate, rotation, m_configuration.m_scale);
-        m_shapeTransformInverse = shapeTransformFinal.GetInverse();
+        AZ::Matrix3x4 shapeTransformFinal;
+        shapeTransformFinal.SetFromEulerDegrees(m_configuration.m_rotate);
+        shapeTransformFinal.SetTranslation(m_configuration.m_translate);
+        shapeTransformFinal.MultiplyByScale(m_configuration.m_scale);
+        m_shapeTransformInverse = shapeTransformFinal.GetInverseFull();
     }
 
     AZ::EntityId GradientTransformComponent::GetShapeEntityId() const
diff --git a/Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.h b/Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.h
index 15aaf40494..5955da95c7 100644
--- a/Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.h
+++ b/Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.h
@@ -15,6 +15,7 @@
 #include <AzCore/Component/Component.h>
 #include <AzCore/Component/TickBus.h>
 #include <AzCore/Math/Aabb.h>
+#include <AzCore/Math/Matrix3x4.h>
 #include <AzCore/Math/Transform.h>
 #include <AzCore/Math/Vector3.h>
 #include <AzCore/std/parallel/atomic.h>
@@ -172,8 +173,8 @@ namespace GradientSignal
         mutable AZStd::recursive_mutex m_cacheMutex;
         GradientTransformConfig m_configuration;
         AZ::Aabb m_shapeBounds = AZ::Aabb::CreateNull();
-        AZ::Transform m_shapeTransformInverse = AZ::Transform::CreateIdentity();
+        AZ::Matrix3x4 m_shapeTransformInverse = AZ::Matrix3x4::CreateIdentity();
         LmbrCentral::DependencyMonitor m_dependencyMonitor;
         AZStd::atomic_bool m_dirty{ false };
     };
-} //namespace GradientSignal
\ No newline at end of file
+} //namespace GradientSignal
diff --git a/Gems/LmbrCentral/Code/Source/Animation/AttachmentComponent.cpp b/Gems/LmbrCentral/Code/Source/Animation/AttachmentComponent.cpp
index 537585f48c..efef5761bc 100644
--- a/Gems/LmbrCentral/Code/Source/Animation/AttachmentComponent.cpp
+++ b/Gems/LmbrCentral/Code/Source/Animation/AttachmentComponent.cpp
@@ -242,14 +242,14 @@ namespace LmbrCentral
         {
             // apply offset in world-space
             finalTransform = m_targetEntityTransform * m_targetBoneTransform;
-            finalTransform.SetScale(AZ::Vector3::CreateOne());
+            finalTransform.SetUniformScale(1.0f);
             finalTransform *= m_targetOffset;
         }
         else if (m_scaleSource == AttachmentConfiguration::ScaleSource::TargetEntityScale)
         {
             // apply offset in target-entity-space (ignoring bone scale)
             AZ::Transform boneNoScale = m_targetBoneTransform;
-            boneNoScale.SetScale(AZ::Vector3::CreateOne());
+            boneNoScale.SetUniformScale(1.0f);
 
             finalTransform = m_targetEntityTransform * boneNoScale * m_targetOffset;
         }
diff --git a/Gems/LmbrCentral/Code/Source/Animation/EditorAttachmentComponent.cpp b/Gems/LmbrCentral/Code/Source/Animation/EditorAttachmentComponent.cpp
index 337da51159..6190f976a0 100644
--- a/Gems/LmbrCentral/Code/Source/Animation/EditorAttachmentComponent.cpp
+++ b/Gems/LmbrCentral/Code/Source/Animation/EditorAttachmentComponent.cpp
@@ -124,7 +124,7 @@ namespace LmbrCentral
     {
         AZ::Transform offset = AZ::ConvertEulerDegreesToTransform(m_rotationOffset);
         offset.SetTranslation(m_positionOffset);
-        offset.MultiplyByScale(m_scaleOffset);
+        offset.MultiplyByUniformScale(m_scaleOffset.GetMaxElement());
         return offset;
     }
 
diff --git a/Gems/LmbrCentral/Code/Source/Scripting/EditorLookAtComponent.cpp b/Gems/LmbrCentral/Code/Source/Scripting/EditorLookAtComponent.cpp
index ab22514cf8..7a2cc52627 100644
--- a/Gems/LmbrCentral/Code/Source/Scripting/EditorLookAtComponent.cpp
+++ b/Gems/LmbrCentral/Code/Source/Scripting/EditorLookAtComponent.cpp
@@ -169,22 +169,24 @@ namespace LmbrCentral
         {
             AZ::TransformNotificationBus::MultiHandler::BusDisconnect(GetEntityId());
             {
-                AZ::Transform currentTM = AZ::Transform::CreateIdentity();
-                EBUS_EVENT_ID_RESULT(currentTM, GetEntityId(), AZ::TransformBus, GetWorldTM);
-                AZ::Vector3 currentScale = currentTM.ExtractScale();
+                AZ::Transform sourceTM = AZ::Transform::CreateIdentity();
+                AZ::TransformBus::EventResult(sourceTM, GetEntityId(), &AZ::TransformBus::Events::GetWorldTM);
 
                 AZ::Transform targetTM = AZ::Transform::CreateIdentity();
-                EBUS_EVENT_ID_RESULT(targetTM, m_targetId, AZ::TransformBus, GetWorldTM);
+                AZ::TransformBus::EventResult(targetTM, m_targetId, &AZ::TransformBus::Events::GetWorldTM);
 
                 AZ::Transform lookAtTransform = AZ::Transform::CreateLookAt(
-                    currentTM.GetTranslation(),
+                    sourceTM.GetTranslation(),
                     targetTM.GetTranslation(),
                     m_forwardAxis
                     );
 
-                lookAtTransform.MultiplyByScale(currentScale);
+                // update the rotation and translation for sourceTM based on lookAtTransform, but leave scale unchanged
+                sourceTM.SetRotation(lookAtTransform.GetRotation());
+                sourceTM.SetTranslation(lookAtTransform.GetTranslation());
 
                 EBUS_EVENT_ID(GetEntityId(), AZ::TransformBus, SetWorldTM, lookAtTransform);
+                AZ::TransformBus::Event(GetEntityId(), &AZ::TransformBus::Events::SetWorldTM, sourceTM);
             }
             AZ::TransformNotificationBus::MultiHandler::BusConnect(GetEntityId());
         }
diff --git a/Gems/LmbrCentral/Code/Source/Shape/BoxShape.cpp b/Gems/LmbrCentral/Code/Source/Shape/BoxShape.cpp
index 2830f514fe..a2ee4d986f 100644
--- a/Gems/LmbrCentral/Code/Source/Shape/BoxShape.cpp
+++ b/Gems/LmbrCentral/Code/Source/Shape/BoxShape.cpp
@@ -251,7 +251,7 @@ namespace LmbrCentral
         const AZ::Transform& currentTransform, const BoxShapeConfig& configuration, const AZ::Vector3& currentNonUniformScale)
     {
         AZ::Transform worldFromLocalNormalized = currentTransform;
-        const float entityScale = worldFromLocalNormalized.ExtractScale().GetMaxElement();
+        const float entityScale = worldFromLocalNormalized.ExtractUniformScale();
 
         m_currentPosition = worldFromLocalNormalized.GetTranslation();
         m_scaledDimensions = configuration.m_dimensions * currentNonUniformScale * entityScale;
diff --git a/Gems/LmbrCentral/Code/Source/Shape/PolygonPrismShape.cpp b/Gems/LmbrCentral/Code/Source/Shape/PolygonPrismShape.cpp
index 89c5028e93..db5aaf097c 100644
--- a/Gems/LmbrCentral/Code/Source/Shape/PolygonPrismShape.cpp
+++ b/Gems/LmbrCentral/Code/Source/Shape/PolygonPrismShape.cpp
@@ -437,22 +437,18 @@ namespace LmbrCentral
             const float height = polygonPrism.GetHeight();
             const AZ::Vector3& nonUniformScale = polygonPrism.GetNonUniformScale();
 
-            AZ::Transform worldFromLocalUniformScale = worldFromLocal;
-            const float entityScale = worldFromLocalUniformScale.ExtractScale().GetMaxElement();
-            worldFromLocalUniformScale *= AZ::Transform::CreateScale(AZ::Vector3(entityScale));
-
             AZ::Aabb aabb = AZ::Aabb::CreateNull();
             // check base of prism
             for (const AZ::Vector2& vertex : vertexContainer.GetVertices())
             {
-                aabb.AddPoint(worldFromLocalUniformScale.TransformPoint(nonUniformScale * AZ::Vector3(vertex.GetX(), vertex.GetY(), 0.0f)));
+                aabb.AddPoint(worldFromLocal.TransformPoint(nonUniformScale * AZ::Vector3(vertex.GetX(), vertex.GetY(), 0.0f)));
             }
 
             // check top of prism
             // set aabb to be height of prism - ensure entire polygon prism shape is enclosed in aabb
             for (const AZ::Vector2& vertex : vertexContainer.GetVertices())
             {
-                aabb.AddPoint(worldFromLocalUniformScale.TransformPoint(nonUniformScale * AZ::Vector3(vertex.GetX(), vertex.GetY(), height)));
+                aabb.AddPoint(worldFromLocal.TransformPoint(nonUniformScale * AZ::Vector3(vertex.GetX(), vertex.GetY(), height)));
             }
 
             return aabb;
@@ -468,14 +464,10 @@ namespace LmbrCentral
             const AZStd::vector<AZ::Vector2>& vertices = polygonPrism.m_vertexContainer.GetVertices();
             const size_t vertexCount = vertices.size();
 
-            AZ::Transform worldFromLocalWithUniformScale = worldFromLocal;
-            const float transformScale = worldFromLocalWithUniformScale.ExtractScale().GetMaxElement();
-            worldFromLocalWithUniformScale *= AZ::Transform::CreateScale(AZ::Vector3(transformScale));
-
             // transform point to local space
             // it's fine to invert the transform including scale here, because it won't affect whether the point is inside the prism
             const AZ::Vector3 localPoint =
-                worldFromLocalWithUniformScale.GetInverse().TransformPoint(point) / polygonPrism.GetNonUniformScale();
+                worldFromLocal.GetInverse().TransformPoint(point) / polygonPrism.GetNonUniformScale();
 
             // ensure the point is not above or below the prism (in its local space)
             if (localPoint.GetZ() < 0.0f || localPoint.GetZ() > polygonPrism.GetHeight())
@@ -534,7 +526,7 @@ namespace LmbrCentral
             // but inverting any scale in the transform would mess up the distance, so extract that first and apply scale separately to the
             // prism
             AZ::Transform worldFromLocalNoScale = worldFromLocal;
-            const float transformScale = worldFromLocalNoScale.ExtractScale().GetMaxElement();
+            const float transformScale = worldFromLocalNoScale.ExtractUniformScale();
             const AZ::Vector3 combinedScale = transformScale * nonUniformScale;
             const float scaledHeight = height * combinedScale.GetZ();
 
@@ -610,9 +602,9 @@ namespace LmbrCentral
             }
 
             // transform ray into local space
-            AZ::Transform worldFromLocalNomalized = worldFromLocal;
-            const float entityScale = worldFromLocalNomalized.ExtractScale().GetMaxElement();
-            const AZ::Transform localFromWorldNormalized = worldFromLocalNomalized.GetInverse();
+            AZ::Transform worldFromLocalNormalized = worldFromLocal;
+            const float entityScale = worldFromLocalNormalized.ExtractUniformScale();
+            const AZ::Transform localFromWorldNormalized = worldFromLocalNormalized.GetInverse();
             const float rayLength = 1000.0f;
             const AZ::Vector3 localSrc = localFromWorldNormalized.TransformPoint(src);
             const AZ::Vector3 localDir = localFromWorldNormalized.TransformVector(dir);
diff --git a/Gems/LmbrCentral/Code/Source/Shape/ShapeDisplay.h b/Gems/LmbrCentral/Code/Source/Shape/ShapeDisplay.h
index 09088f06cd..3591ecde36 100644
--- a/Gems/LmbrCentral/Code/Source/Shape/ShapeDisplay.h
+++ b/Gems/LmbrCentral/Code/Source/Shape/ShapeDisplay.h
@@ -42,15 +42,10 @@ namespace LmbrCentral
             return;
         }
 
-        // only uniform scale is supported in physics so the debug visuals reflect this fact
-        AZ::Transform worldFromLocalWithUniformScale = worldFromLocal;
-        const AZ::Vector3 scale = worldFromLocalWithUniformScale.ExtractScale();
-        worldFromLocalWithUniformScale.MultiplyByScale(AZ::Vector3(scale.GetMaxElement()));
-
-        debugDisplay.PushMatrix(worldFromLocalWithUniformScale);
+        debugDisplay.PushMatrix(worldFromLocal);
 
         drawShape(debugDisplay);
 
         debugDisplay.PopMatrix();
     }
-} // namespace LmbrCentral
\ No newline at end of file
+} // namespace LmbrCentral
diff --git a/Gems/LmbrCentral/Code/Source/Shape/TubeShape.cpp b/Gems/LmbrCentral/Code/Source/Shape/TubeShape.cpp
index 6ca2e55de8..2691ab1557 100644
--- a/Gems/LmbrCentral/Code/Source/Shape/TubeShape.cpp
+++ b/Gems/LmbrCentral/Code/Source/Shape/TubeShape.cpp
@@ -216,11 +216,7 @@ namespace LmbrCentral
             return AZ::Aabb::CreateNull();
         }
 
-        AZ::Transform worldFromLocalUniformScale = m_currentTransform;
-        const float maxScale = worldFromLocalUniformScale.ExtractScale().GetMaxElement();
-        worldFromLocalUniformScale *= AZ::Transform::CreateScale(AZ::Vector3(maxScale));
-
-        return CalculateTubeBounds(*this, worldFromLocalUniformScale);
+        return CalculateTubeBounds(*this, m_currentTransform);
     }
 
     void TubeShape::GetTransformAndLocalBounds(AZ::Transform& transform, AZ::Aabb& bounds)
@@ -236,46 +232,38 @@ namespace LmbrCentral
             return false;
         }
 
-        AZ::Transform worldFromLocalNormalized = m_currentTransform;
-        const AZ::Vector3 scale = AZ::Vector3(worldFromLocalNormalized.ExtractScale().GetMaxElement());
-        const AZ::Transform localFromWorldNormalized = worldFromLocalNormalized.GetInverse();
-        const AZ::Vector3 localPoint = localFromWorldNormalized.TransformPoint(point) * scale.GetReciprocal();
+        const float scale = m_currentTransform.GetUniformScale();
+        const AZ::Vector3 localPoint = m_currentTransform.GetInverse().TransformPoint(point);
 
         const auto address = m_spline->GetNearestAddressPosition(localPoint).m_splineAddress;
         const float radiusSq = powf(m_radius, 2.0f);
         const float variableRadiusSq =
             powf(m_variableRadius.GetElementInterpolated(address, Lerpf), 2.0f);
 
-        return (m_spline->GetPosition(address) - localPoint).GetLengthSq() < (radiusSq + variableRadiusSq) *
-            scale.GetMaxElement();
+        return (m_spline->GetPosition(address) - localPoint).GetLengthSq() < (radiusSq + variableRadiusSq) * scale;
     }
 
     float TubeShape::DistanceSquaredFromPoint(const AZ::Vector3& point)
     {
-        AZ::Transform worldFromLocalNormalized = m_currentTransform;
-        const AZ::Vector3 maxScale = AZ::Vector3(worldFromLocalNormalized.ExtractScale().GetMaxElement());
-        const AZ::Transform localFromWorldNormalized = worldFromLocalNormalized.GetInverse();
-        const AZ::Vector3 localPoint = localFromWorldNormalized.TransformPoint(point) * maxScale.GetReciprocal();
+        const float scale = m_currentTransform.GetUniformScale();
+        const AZ::Transform localFromWorld = m_currentTransform.GetInverse();
+        const AZ::Vector3 localPoint = localFromWorld.TransformPoint(point);
 
         const auto splineQueryResult = m_spline->GetNearestAddressPosition(localPoint);
         const float variableRadius =
             m_variableRadius.GetElementInterpolated(splineQueryResult.m_splineAddress, Lerpf);
 
-        return powf((sqrtf(splineQueryResult.m_distanceSq) - (m_radius + variableRadius)) * maxScale.GetMaxElement(), 2.0f);
+        return powf((sqrtf(splineQueryResult.m_distanceSq) - (m_radius + variableRadius)) * scale, 2.0f);
     }
 
     bool TubeShape::IntersectRay(const AZ::Vector3& src, const AZ::Vector3& dir, float& distance)
     {
-        AZ::Transform transformUniformScale = m_currentTransform;
-        const float maxScale = transformUniformScale.ExtractScale().GetMaxElement();
-        transformUniformScale *= AZ::Transform::CreateScale(AZ::Vector3(maxScale));
-
-        const auto splineQueryResult = IntersectSpline(transformUniformScale, src, dir, *m_spline);
+        const auto splineQueryResult = IntersectSpline(m_currentTransform, src, dir, *m_spline);
         const float variableRadius = m_variableRadius.GetElementInterpolated(
             splineQueryResult.m_splineAddress, Lerpf);
 
         const float totalRadius = m_radius + variableRadius;
-        distance = (splineQueryResult.m_rayDistance - totalRadius) * m_currentTransform.GetScale().GetMaxElement();
+        distance = (splineQueryResult.m_rayDistance - totalRadius) * m_currentTransform.GetUniformScale();
 
         return static_cast<float>(sqrtf(splineQueryResult.m_distanceSq)) < totalRadius;
     }
diff --git a/Gems/LmbrCentral/Code/Tests/BoxShapeTest.cpp b/Gems/LmbrCentral/Code/Tests/BoxShapeTest.cpp
index fd1e4ae4f1..24ee8ace2f 100644
--- a/Gems/LmbrCentral/Code/Tests/BoxShapeTest.cpp
+++ b/Gems/LmbrCentral/Code/Tests/BoxShapeTest.cpp
@@ -262,7 +262,7 @@ namespace UnitTest
             AZ::Transform::CreateFromQuaternionAndTranslation(
                 AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisY(), AZ::Constants::QuarterPi),
                 AZ::Vector3(0.0f, 0.0f, 5.0f)) *
-            AZ::Transform::CreateScale(AZ::Vector3(3.0f)),
+            AZ::Transform::CreateUniformScale(3.0f),
             AZ::Vector3(2.0f, 4.0f, 1.0f), entity);
 
         bool rayHit = false;
@@ -295,7 +295,7 @@ namespace UnitTest
     {
         AZ::Entity entity;
         AZ::Transform transform = AZ::Transform::CreateTranslation(AZ::Vector3(2.0f, -5.0f, 3.0f));
-        transform.MultiplyByScale(AZ::Vector3(0.5f));
+        transform.MultiplyByUniformScale(0.5f);
         const AZ::Vector3 dimensions(2.2f, 1.8f, 0.4f);
         const AZ::Vector3 nonUniformScale(0.2f, 2.6f, 1.2f);
         CreateBoxWithNonUniformScale(transform, dimensions, nonUniformScale, entity);
@@ -340,7 +340,7 @@ namespace UnitTest
         AZ::Entity entity;
         AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation(
             AZ::Quaternion(0.50f, 0.10f, 0.02f, 0.86f), AZ::Vector3(4.0f, 1.0f, -2.0f));
-        transform.MultiplyByScale(AZ::Vector3(1.5f));
+        transform.MultiplyByUniformScale(1.5f);
         const AZ::Vector3 dimensions(1.2f, 0.7f, 2.1f);
         const AZ::Vector3 nonUniformScale(0.8f, 0.6f, 0.7f);
         CreateBoxWithNonUniformScale(transform, dimensions, nonUniformScale, entity);
@@ -433,7 +433,7 @@ namespace UnitTest
             AZ::Transform::CreateFromQuaternionAndTranslation(
                 AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisY(), AZ::Constants::QuarterPi),
                 AZ::Vector3::CreateZero()) *
-            AZ::Transform::CreateScale(AZ::Vector3(3.0f)),
+            AZ::Transform::CreateUniformScale(3.0f),
             AZ::Vector3(2.0f, 4.0f, 1.0f), entity);
 
         AZ::Aabb aabb;
@@ -483,7 +483,7 @@ namespace UnitTest
         AZ::Transform transformIn = AZ::Transform::CreateFromQuaternionAndTranslation(
             AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisX(), AZ::Constants::QuarterPi) * AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisY(), AZ::Constants::QuarterPi),
             AZ::Vector3(9.0f, 11.0f, 13.0f));
-        transformIn.MultiplyByScale(AZ::Vector3(3.0f));
+        transformIn.MultiplyByUniformScale(3.0f);
         CreateBox(transformIn, AZ::Vector3(1.5f, 3.5f, 5.5f), entity);
 
         AZ::Transform transformOut;
@@ -500,7 +500,7 @@ namespace UnitTest
         AZ::Entity entity;
         AZ::Transform transformIn = AZ::Transform::CreateFromQuaternionAndTranslation(
             AZ::Quaternion(0.62f, 0.62f, 0.14f, 0.46f), AZ::Vector3(0.8f, -1.2f, 2.7f));
-        transformIn.MultiplyByScale(AZ::Vector3(2.0f));
+        transformIn.MultiplyByUniformScale(2.0f);
         const AZ::Vector3 nonUniformScale(1.5f, 2.0f, 0.4f);
         const AZ::Vector3 boxDimensions(2.0f, 1.7f, 0.5f);
         CreateBoxWithNonUniformScale(transformIn, nonUniformScale, boxDimensions, entity);
@@ -531,7 +531,7 @@ namespace UnitTest
             AZ::Transform::CreateFromQuaternionAndTranslation(
                 AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisZ(), AZ::Constants::QuarterPi),
                 AZ::Vector3(23.0f, 12.0f, 40.0f)) *
-            AZ::Transform::CreateScale(AZ::Vector3(3.0f)),
+            AZ::Transform::CreateUniformScale(3.0f),
             AZ::Vector3(2.0f, 6.0f, 3.5f), entity);
 
         // test some pairs of nearby points which should be just either side of the surface of the box
@@ -551,7 +551,7 @@ namespace UnitTest
             AZ::Transform::CreateTranslation(AZ::Vector3(23.0f, 12.0f, 40.0f)) *
             AZ::Transform::CreateRotationX(-AZ::Constants::QuarterPi) *
             AZ::Transform::CreateRotationZ(AZ::Constants::QuarterPi) *
-            AZ::Transform::CreateScale(AZ::Vector3(2.0f)),
+            AZ::Transform::CreateUniformScale(2.0f),
             AZ::Vector3(4.0f, 7.0f, 3.5f), entity);
 
         // test some pairs of nearby points which should be just either side of the surface of the box
@@ -588,8 +588,8 @@ namespace UnitTest
         CreateBox(
             AZ::Transform::CreateTranslation(AZ::Vector3(10.0f, 37.0f, 32.0f)) *
             AZ::Transform::CreateRotationZ(AZ::Constants::QuarterPi) *
-            AZ::Transform::CreateScale(AZ::Vector3(3.0f, 1.0f, 1.0f)),
-            AZ::Vector3(4.0f, 2.0f, 10.0f), entity);
+            AZ::Transform::CreateUniformScale(2.0f),
+            AZ::Vector3(6.0f, 1.0f, 5.0f), entity);
 
         float distance;
         LmbrCentral::ShapeComponentRequestsBus::EventResult(
@@ -606,8 +606,8 @@ namespace UnitTest
             AZ::Transform::CreateTranslation(AZ::Vector3(10.0f, 37.0f, 32.0f)) *
             AZ::Transform::CreateRotationX(AZ::Constants::HalfPi) *
             AZ::Transform::CreateRotationY(AZ::Constants::HalfPi) *
-            AZ::Transform::CreateScale(AZ::Vector3(3.0f, 1.0f, 1.0f)),
-            AZ::Vector3(4.0f, 2.0f, 10.0f), entity);
+            AZ::Transform::CreateUniformScale(0.5f),
+            AZ::Vector3(24.0f, 4.0f, 20.0f), entity);
 
         float distance;
         LmbrCentral::ShapeComponentRequestsBus::EventResult(
@@ -621,7 +621,7 @@ namespace UnitTest
         AZ::Entity entity;
         AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation(
             AZ::Quaternion::CreateRotationY(AZ::DegToRad(30.0f)), AZ::Vector3(3.0f, 4.0f, 5.0f));
-        transform.MultiplyByScale(AZ::Vector3(2.0f));
+        transform.MultiplyByUniformScale(2.0f);
         const AZ::Vector3 dimensions(2.0f, 3.0f, 1.5f);
         const AZ::Vector3 nonUniformScale(1.4f, 2.2f, 0.8f);
         CreateBoxWithNonUniformScale(transform, nonUniformScale, dimensions, entity);
@@ -638,7 +638,7 @@ namespace UnitTest
         AZ::Entity entity;
         AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation(
             AZ::Quaternion(0.70f, 0.10f, 0.34f, 0.62f), AZ::Vector3(3.0f, -1.0f, 2.0f));
-        transform.MultiplyByScale(AZ::Vector3(2.0f));
+        transform.MultiplyByUniformScale(2.0f);
         const AZ::Vector3 dimensions(1.2f, 0.8f, 1.7f);
         const AZ::Vector3 nonUniformScale(2.4f, 1.3f, 1.8f);
         CreateBoxWithNonUniformScale(transform, nonUniformScale, dimensions, entity);
diff --git a/Gems/LmbrCentral/Code/Tests/CapsuleShapeTest.cpp b/Gems/LmbrCentral/Code/Tests/CapsuleShapeTest.cpp
index 9b57cd46c7..3274585e63 100644
--- a/Gems/LmbrCentral/Code/Tests/CapsuleShapeTest.cpp
+++ b/Gems/LmbrCentral/Code/Tests/CapsuleShapeTest.cpp
@@ -144,7 +144,7 @@ namespace UnitTest
         CreateCapsule(
             AZ::Transform::CreateTranslation(AZ::Vector3(-4.0f, -12.0f, -3.0f)) *
             AZ::Transform::CreateRotationX(AZ::Constants::HalfPi) *
-            AZ::Transform::CreateScale(AZ::Vector3(6.0f)),
+            AZ::Transform::CreateUniformScale(6.0f),
             0.25f, 1.5f, entity);
 
         bool rayHit = false;
@@ -208,7 +208,7 @@ namespace UnitTest
     TEST_F(CapsuleShapeTest, GetAabb3)
     {
         AZ::Entity entity;
-        CreateCapsule(AZ::Transform::CreateScale(AZ::Vector3(3.5f)), 2.0f, 4.0f, entity);
+        CreateCapsule(AZ::Transform::CreateUniformScale(3.5f), 2.0f, 4.0f, entity);
 
         AZ::Aabb aabb;
         LmbrCentral::ShapeComponentRequestsBus::EventResult(
@@ -224,7 +224,7 @@ namespace UnitTest
         AZ::Entity entity;
         CreateCapsule(
             AZ::Transform::CreateTranslation(AZ::Vector3(5.0f, 20.0f, 0.0f)) *
-            AZ::Transform::CreateScale(AZ::Vector3(2.5f)), 1.0f, 5.0f, entity);
+            AZ::Transform::CreateUniformScale(2.5f), 1.0f, 5.0f, entity);
 
         AZ::Aabb aabb;
         LmbrCentral::ShapeComponentRequestsBus::EventResult(
@@ -255,7 +255,7 @@ namespace UnitTest
         AZ::Transform transformIn = AZ::Transform::CreateFromQuaternionAndTranslation(
             AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisX(), AZ::Constants::HalfPi) *
             AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisY(), AZ::Constants::QuarterPi), AZ::Vector3(-10.0f, -10.0f, 0.0f));
-        transformIn.MultiplyByScale(AZ::Vector3(3.0f));
+        transformIn.MultiplyByUniformScale(3.0f);
         CreateCapsule(transformIn, 5.0f, 2.0f, entity);
 
         AZ::Transform transformOut;
@@ -273,7 +273,7 @@ namespace UnitTest
         AZ::Transform transformIn = AZ::Transform::CreateFromQuaternionAndTranslation(
             AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisX(), AZ::Constants::HalfPi) *
             AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisY(), AZ::Constants::QuarterPi), AZ::Vector3(-10.0f, -10.0f, 0.0f));
-        transformIn.MultiplyByScale(AZ::Vector3(3.0f));
+        transformIn.MultiplyByUniformScale(3.0f);
         CreateCapsule(transformIn, 2.0f, 5.0f, entity);
 
         AZ::Transform transformOut;
@@ -291,7 +291,7 @@ namespace UnitTest
         AZ::Entity entity;
         CreateCapsule(
             AZ::Transform::CreateTranslation(AZ::Vector3(27.0f, 28.0f, 38.0f)) *
-            AZ::Transform::CreateScale(AZ::Vector3(2.5f, 1.0f, 1.0f)), // test max scale
+            AZ::Transform::CreateUniformScale(2.5f),
             0.5f, 2.0f, entity);
 
         bool inside;
@@ -309,7 +309,7 @@ namespace UnitTest
             AZ::Transform::CreateTranslation(AZ::Vector3(27.0f, 28.0f, 38.0f)) *
             AZ::Transform::CreateRotationX(AZ::Constants::HalfPi) *
             AZ::Transform::CreateRotationY(AZ::Constants::QuarterPi) *
-            AZ::Transform::CreateScale(AZ::Vector3(0.5f)),
+            AZ::Transform::CreateUniformScale(0.5f),
             0.5f, 2.0f, entity);
 
         bool inside;
@@ -327,7 +327,7 @@ namespace UnitTest
             AZ::Transform::CreateTranslation(AZ::Vector3(27.0f, 28.0f, 38.0f)) *
             AZ::Transform::CreateRotationX(AZ::Constants::HalfPi) *
             AZ::Transform::CreateRotationY(AZ::Constants::QuarterPi) *
-            AZ::Transform::CreateScale(AZ::Vector3(2.0f)),
+            AZ::Transform::CreateUniformScale(2.0f),
             0.5f, 4.0f, entity);
 
         float distance;
@@ -345,7 +345,7 @@ namespace UnitTest
             AZ::Transform::CreateTranslation(AZ::Vector3(27.0f, 28.0f, 38.0f)) *
             AZ::Transform::CreateRotationX(AZ::Constants::HalfPi) *
             AZ::Transform::CreateRotationY(AZ::Constants::QuarterPi) *
-            AZ::Transform::CreateScale(AZ::Vector3(2.0f)),
+            AZ::Transform::CreateUniformScale(2.0f),
             0.5f, 4.0f, entity);
 
         float distance;
diff --git a/Gems/LmbrCentral/Code/Tests/CylinderShapeTest.cpp b/Gems/LmbrCentral/Code/Tests/CylinderShapeTest.cpp
index 893ed3fcac..115abcf5ff 100644
--- a/Gems/LmbrCentral/Code/Tests/CylinderShapeTest.cpp
+++ b/Gems/LmbrCentral/Code/Tests/CylinderShapeTest.cpp
@@ -138,7 +138,7 @@ namespace UnitTest
             { AZ::Transform::CreateTranslation(AZ::Vector3(-14.0f, -14.0f, -1.0f)) *
                     AZ::Transform::CreateRotationY(AZ::Constants::HalfPi) *
                     AZ::Transform::CreateRotationZ(AZ::Constants::HalfPi) *
-                    AZ::Transform::CreateScale(AZ::Vector3(4.0f)),
+                    AZ::Transform::CreateUniformScale(4.0f),
                     1.0f, 1.25f },
             // Result: hit, distance, epsilon
             { true, 2.5f, 1e-2f }
@@ -203,7 +203,7 @@ namespace UnitTest
         // Test case 2
         {   // Cylinder: transform, radius, height
             { AZ::Transform::CreateTranslation(AZ::Vector3(-10.0f, -10.0f, 10.0f)) *
-            AZ::Transform::CreateScale(AZ::Vector3(3.5f)),
+            AZ::Transform::CreateUniformScale(3.5f),
             1.0f, 5.0f },
             // AABB: min, max
             { AZ::Vector3(-13.5f, -13.5f, 1.25f), AZ::Vector3(-6.5f, -6.5f, 18.75f) }   },
@@ -236,7 +236,7 @@ namespace UnitTest
             { AZ::Vector3(-5.0f, -5.0f, -0.5f), AZ::Vector3(5.0f, 5.0f, 0.5f) } },
         // Test case 1
         {   // Cylinder: transform, radius, height
-            { AZ::Transform::CreateTranslation(AZ::Vector3(-10.0f, -10.0f, 10.0f)) * AZ::Transform::CreateScale(AZ::Vector3(3.5f)),
+            { AZ::Transform::CreateTranslation(AZ::Vector3(-10.0f, -10.0f, 10.0f)) * AZ::Transform::CreateUniformScale(3.5f),
             5.0f, 5.0f },
             // Local bounds: min, max
             { AZ::Vector3(-5.0f, -5.0f, -2.5f), AZ::Vector3(5.0f, 5.0f, 2.5f) } },
@@ -264,7 +264,7 @@ namespace UnitTest
         // Test case 0
         {   // Cylinder: transform, radius, height
             {AZ::Transform::CreateTranslation(AZ::Vector3(27.0f, 28.0f, 38.0f)) *
-            AZ::Transform::CreateScale(AZ::Vector3(2.5f, 1.0f, 1.0f)), // test max scale
+            AZ::Transform::CreateUniformScale(2.5f),
             0.5f, 2.0f},
             // Point
             AZ::Vector3(27.0f, 28.5f, 40.0f),
@@ -275,7 +275,7 @@ namespace UnitTest
             {AZ::Transform::CreateTranslation(AZ::Vector3(27.0f, 28.0f, 38.0f)) *
             AZ::Transform::CreateRotationX(AZ::Constants::HalfPi) *
             AZ::Transform::CreateRotationY(AZ::Constants::QuarterPi) *
-            AZ::Transform::CreateScale(AZ::Vector3(0.5f)),
+            AZ::Transform::CreateUniformScale(0.5f),
             0.5f, 2.0f},
             // Point
             AZ::Vector3(27.0f, 28.155f, 37.82f),
@@ -316,7 +316,7 @@ namespace UnitTest
             { AZ::Transform::CreateTranslation(AZ::Vector3(27.0f, 28.0f, 38.0f)) *
             AZ::Transform::CreateRotationX(AZ::Constants::HalfPi) *
             AZ::Transform::CreateRotationY(AZ::Constants::QuarterPi) *
-            AZ::Transform::CreateScale(AZ::Vector3(2.0f)),
+            AZ::Transform::CreateUniformScale(2.0f),
             0.5f, 4.0f },
             // Point
             AZ::Vector3(27.0f, 28.0f, 41.0f),
@@ -327,7 +327,7 @@ namespace UnitTest
             { AZ::Transform::CreateTranslation(AZ::Vector3(27.0f, 28.0f, 38.0f)) *
             AZ::Transform::CreateRotationX(AZ::Constants::HalfPi) *
             AZ::Transform::CreateRotationY(AZ::Constants::QuarterPi) *
-            AZ::Transform::CreateScale(AZ::Vector3(2.0f)),
+            AZ::Transform::CreateUniformScale(2.0f),
             0.5f, 4.0f },
             // Point
             AZ::Vector3(22.757f, 32.243f, 38.0f),
diff --git a/Gems/LmbrCentral/Code/Tests/DiskShapeTest.cpp b/Gems/LmbrCentral/Code/Tests/DiskShapeTest.cpp
index 4a39cd966e..c3683cc33b 100644
--- a/Gems/LmbrCentral/Code/Tests/DiskShapeTest.cpp
+++ b/Gems/LmbrCentral/Code/Tests/DiskShapeTest.cpp
@@ -307,7 +307,7 @@ namespace UnitTest
         AZ::Entity entity;
         CreateDisk(
             AZ::Transform::CreateTranslation(AZ::Vector3(100.0f, 200.0f, 300.0f)) *
-            AZ::Transform::CreateScale(AZ::Vector3(2.5f)),
+            AZ::Transform::CreateUniformScale(2.5f),
             0.5f, entity);
 
         AZ::Aabb aabb;
diff --git a/Gems/LmbrCentral/Code/Tests/PolygonPrismShapeTest.cpp b/Gems/LmbrCentral/Code/Tests/PolygonPrismShapeTest.cpp
index 46c3da90ab..f12ca69425 100644
--- a/Gems/LmbrCentral/Code/Tests/PolygonPrismShapeTest.cpp
+++ b/Gems/LmbrCentral/Code/Tests/PolygonPrismShapeTest.cpp
@@ -329,7 +329,7 @@ namespace UnitTest
         AZ::Entity entity;
         AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation(
             AZ::Quaternion::CreateRotationY(AZ::DegToRad(45.0f)), AZ::Vector3(3.0f, 4.0f, 5.0f));
-        transform.MultiplyByScale(AZ::Vector3(1.5f, 1.5f, 1.5f));
+        transform.MultiplyByUniformScale(1.5f);
         const float height = 1.2f;
         const AZ::Vector3 nonUniformScale(2.0f, 1.2f, 0.5f);
         const AZStd::vector<AZ::Vector2> vertices =
@@ -447,7 +447,7 @@ namespace UnitTest
         AZ::Entity entity;
         AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation(
             AZ::Quaternion::CreateRotationY(AZ::DegToRad(45.0f)), AZ::Vector3(3.0f, 4.0f, 5.0f));
-        transform.MultiplyByScale(AZ::Vector3(1.5f, 1.5f, 1.5f));
+        transform.MultiplyByUniformScale(1.5f);
         const float height = 1.2f;
         const AZ::Vector3 nonUniformScale(2.0f, 1.2f, 0.5f);
         const AZStd::vector<AZ::Vector2> vertices =
@@ -608,7 +608,7 @@ namespace UnitTest
         AZ::Entity entity;
         CreatePolygonPrism(
             AZ::Transform::CreateTranslation(AZ::Vector3(5.0f, 15.0f, 40.0f)) *
-            AZ::Transform::CreateScale(AZ::Vector3(3.0f)), 2.0f,
+            AZ::Transform::CreateUniformScale(3.0f), 2.0f,
             AZStd::vector<AZ::Vector2>(
             {
                 AZ::Vector2(-2.0f, -2.0f),
@@ -669,7 +669,7 @@ namespace UnitTest
         AZ::Entity entity;
         AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation(
             AZ::Quaternion::CreateRotationY(AZ::DegToRad(60.0f)), AZ::Vector3(1.0f, 2.5f, -1.0f));
-        transform.MultiplyByScale(AZ::Vector3(2.0f, 2.0f, 2.0f));
+        transform.MultiplyByUniformScale(2.0f);
         const float height = 1.5f;
         const AZ::Vector3 nonUniformScale(0.5f, 1.5f, 2.0f);
 
@@ -772,7 +772,7 @@ namespace UnitTest
         AZ::Entity entity;
         CreatePolygonPrism(
             AZ::Transform::CreateTranslation(AZ::Vector3(5.0f, 15.0f, 40.0f)) *
-            AZ::Transform::CreateScale(AZ::Vector3(3.0f)), 1.5f,
+            AZ::Transform::CreateUniformScale(3.0f), 1.5f,
             AZStd::vector<AZ::Vector2>(
             {
                 AZ::Vector2(-2.0f, -2.0f),
@@ -795,7 +795,7 @@ namespace UnitTest
         AZ::Entity entity;
         AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation(
             AZ::Quaternion::CreateRotationX(AZ::DegToRad(30.0f)), AZ::Vector3(2.0f, -5.0f, 3.0f));
-        transform.MultiplyByScale(AZ::Vector3(2.0f, 2.0f, 2.0f));
+        transform.MultiplyByUniformScale(2.0f);
         const float height = 1.2f;
         const AZ::Vector3 nonUniformScale(1.5f, 0.8f, 2.0f);
         const AZStd::vector<AZ::Vector2> vertices =
diff --git a/Gems/LmbrCentral/Code/Tests/QuadShapeTest.cpp b/Gems/LmbrCentral/Code/Tests/QuadShapeTest.cpp
index d70a9344a4..4b6eae4bb8 100644
--- a/Gems/LmbrCentral/Code/Tests/QuadShapeTest.cpp
+++ b/Gems/LmbrCentral/Code/Tests/QuadShapeTest.cpp
@@ -188,7 +188,7 @@ namespace UnitTest
         AZ::Entity entity;
         AZ::Transform transformIn = AZ::Transform::CreateFromQuaternionAndTranslation(
             AZ::Quaternion(0.46f, 0.34f, 0.02f, 0.82f), AZ::Vector3(1.7f, -0.4f, 2.3f));
-        transformIn.MultiplyByScale(AZ::Vector3(2.2f));
+        transformIn.MultiplyByUniformScale(2.2f);
         const AZ::Vector3 nonUniformScale(0.8f, 0.6f, 1.3f);
         const float width = 0.7f;
         const float height = 1.3f;
@@ -327,7 +327,7 @@ namespace UnitTest
         AZ::Entity entity;
         AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation(
             AZ::Quaternion(0.64f, 0.16f, 0.68f, 0.32f), AZ::Vector3(0.4f, -2.3f, -0.9f));
-        transform.MultiplyByScale(AZ::Vector3(1.3f));
+        transform.MultiplyByUniformScale(1.3f);
         const AZ::Vector3 nonUniformScale(0.7f, 0.5f, 1.3f);
         const float width = 0.9f;
         const float height = 1.3f;
@@ -384,7 +384,7 @@ namespace UnitTest
         AZ::Entity entity;
         CreateQuad(
             AZ::Transform::CreateTranslation(AZ::Vector3(100.0f, 200.0f, 300.0f)) *
-            AZ::Transform::CreateScale(AZ::Vector3(2.5f)),
+            AZ::Transform::CreateUniformScale(2.5f),
             1.0f, 2.0f, entity);
 
         AZ::Aabb aabb;
@@ -425,7 +425,7 @@ namespace UnitTest
         AZ::Entity entity;
         AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation(
             AZ::Quaternion(0.44f, 0.24f, 0.48f, 0.72f), AZ::Vector3(3.4f, 1.2f, -2.8f));
-        transform.MultiplyByScale(AZ::Vector3(1.5f));
+        transform.MultiplyByUniformScale(1.5f);
         const AZ::Vector3 nonUniformScale(1.2f, 1.1f, 0.8f);
         const float width = 1.2f;
         const float height = 1.7f;
@@ -518,7 +518,7 @@ namespace UnitTest
         AZ::Entity entity;
         AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation(
             AZ::Quaternion(0.24f, 0.72f, 0.44f, 0.48f), AZ::Vector3(2.7f, 2.3f, -1.8f));
-        transform.MultiplyByScale(AZ::Vector3(1.2f));
+        transform.MultiplyByUniformScale(1.2f);
         const AZ::Vector3 nonUniformScale(0.4f, 2.2f, 1.3f);
         const float width = 1.6f;
         const float height = 0.7f;
@@ -546,7 +546,7 @@ namespace UnitTest
         AZ::Entity entity;
         AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation(
             AZ::Quaternion(0.70f, 0.10f, 0.34f, 0.62f), AZ::Vector3(3.0f, -1.0f, 2.0f));
-        transform.MultiplyByScale(AZ::Vector3(2.0f));
+        transform.MultiplyByUniformScale(2.0f);
         const AZ::Vector3 nonUniformScale(2.4f, 1.3f, 1.8f);
         const float width = 0.8f;
         const float height = 1.4f;
diff --git a/Gems/LmbrCentral/Code/Tests/SphereShapeTest.cpp b/Gems/LmbrCentral/Code/Tests/SphereShapeTest.cpp
index 563bb16caa..b5e45f2cda 100644
--- a/Gems/LmbrCentral/Code/Tests/SphereShapeTest.cpp
+++ b/Gems/LmbrCentral/Code/Tests/SphereShapeTest.cpp
@@ -179,7 +179,7 @@ namespace UnitTest
         AZ::Entity entity;
         CreateSphere(
             AZ::Transform::CreateTranslation(AZ::Vector3(-8.0f, -15.0f, 5.0f)) *
-            AZ::Transform::CreateScale(AZ::Vector3(5.0f)),
+            AZ::Transform::CreateUniformScale(5.0f),
             0.25f, entity);
 
         bool rayHit = false;
@@ -240,7 +240,7 @@ namespace UnitTest
         AZ::Entity entity;
         CreateSphere(
             AZ::Transform::CreateTranslation(AZ::Vector3(100.0f, 200.0f, 300.0f)) *
-            AZ::Transform::CreateScale(AZ::Vector3(2.5f)),
+            AZ::Transform::CreateUniformScale(2.5f),
             0.5f, entity);
 
         AZ::Aabb aabb;
@@ -269,7 +269,7 @@ namespace UnitTest
     TEST_F(SphereShapeTest, GetTransformAndLocalBounds2)
     {
         AZ::Entity entity;
-        AZ::Transform transformIn = AZ::Transform::CreateTranslation(AZ::Vector3(100.0f, 200.0f, 300.0f)) * AZ::Transform::CreateScale(AZ::Vector3(2.5f));
+        AZ::Transform transformIn = AZ::Transform::CreateTranslation(AZ::Vector3(100.0f, 200.0f, 300.0f)) * AZ::Transform::CreateUniformScale(2.5f);
         CreateSphere(transformIn, 2.0f, entity);
 
         AZ::Transform transformOut;
@@ -287,7 +287,7 @@ namespace UnitTest
         AZ::Entity entity;
         CreateSphere(
             AZ::Transform::CreateTranslation(AZ::Vector3(-30.0f, -30.0f, 22.0f)) *
-            AZ::Transform::CreateScale(AZ::Vector3(2.0f)),
+            AZ::Transform::CreateUniformScale(2.0f),
             1.2f, entity);
 
         bool inside;
@@ -303,7 +303,7 @@ namespace UnitTest
         AZ::Entity entity;
         CreateSphere(
             AZ::Transform::CreateTranslation(AZ::Vector3(-30.0f, -30.0f, 22.0f)) *
-            AZ::Transform::CreateScale(AZ::Vector3(1.5f)),
+            AZ::Transform::CreateUniformScale(1.5f),
             1.6f, entity);
 
         bool inside;
@@ -319,7 +319,7 @@ namespace UnitTest
         AZ::Entity entity;
         CreateSphere(
             AZ::Transform::CreateTranslation(AZ::Vector3(19.0f, 34.0f, 37.0f)) *
-            AZ::Transform::CreateScale(AZ::Vector3(2.0f)),
+            AZ::Transform::CreateUniformScale(2.0f),
             1.0f, entity);
 
         float distance;
@@ -335,7 +335,7 @@ namespace UnitTest
         AZ::Entity entity;
         CreateSphere(
             AZ::Transform::CreateTranslation(AZ::Vector3(19.0f, 34.0f, 37.0f)) *
-            AZ::Transform::CreateScale(AZ::Vector3(0.5f)),
+            AZ::Transform::CreateUniformScale(0.5f),
             1.0f, entity);
 
         float distance;
diff --git a/Gems/LmbrCentral/Code/Tests/TubeShapeTest.cpp b/Gems/LmbrCentral/Code/Tests/TubeShapeTest.cpp
index 65388d1fe5..b8f58d5d20 100644
--- a/Gems/LmbrCentral/Code/Tests/TubeShapeTest.cpp
+++ b/Gems/LmbrCentral/Code/Tests/TubeShapeTest.cpp
@@ -139,7 +139,7 @@ namespace UnitTest
         AZ::Entity entity;
         CreateTube(
             AZ::Transform::CreateTranslation(AZ::Vector3(-40.0f, 6.0f, 1.0f)) *
-            AZ::Transform::CreateScale(AZ::Vector3(2.5f, 1.0f, 1.0f)), // test max scale
+            AZ::Transform::CreateUniformScale(2.5f),
             1.0f,
             entity);
 
diff --git a/Gems/Maestro/Code/Source/Cinematics/AnimAZEntityNode.cpp b/Gems/Maestro/Code/Source/Cinematics/AnimAZEntityNode.cpp
index b0ebb10b0e..54eeb1fcc9 100644
--- a/Gems/Maestro/Code/Source/Cinematics/AnimAZEntityNode.cpp
+++ b/Gems/Maestro/Code/Source/Cinematics/AnimAZEntityNode.cpp
@@ -189,7 +189,7 @@ Quat CAnimAzEntityNode::GetRotate(float time)
 }
 
 //////////////////////////////////////////////////////////////////////////
-void CAnimAzEntityNode::SetScale(float time, const Vec3& scale)
+void CAnimAzEntityNode::SetScale(float time, float scale)
 {
     CAnimComponentNode* transformComponent = GetTransformComponentNode();
     if (transformComponent)
@@ -198,7 +198,7 @@ void CAnimAzEntityNode::SetScale(float time, const Vec3& scale)
     }
 }
 
-Vec3 CAnimAzEntityNode::GetScale()
+float CAnimAzEntityNode::GetScale()
 {
     CAnimComponentNode* transformComponent = GetTransformComponentNode();
     if (transformComponent)
@@ -206,7 +206,7 @@ Vec3 CAnimAzEntityNode::GetScale()
         return transformComponent->GetScale();
     }
 
-    return Vec3(.0f, .0f, .0f);
+    return 0.0f;
 }
 
 Vec3 CAnimAzEntityNode::GetOffsetPosition(const Vec3& position)
diff --git a/Gems/Maestro/Code/Source/Cinematics/AnimAZEntityNode.h b/Gems/Maestro/Code/Source/Cinematics/AnimAZEntityNode.h
index 863d0e927f..d5af311b70 100644
--- a/Gems/Maestro/Code/Source/Cinematics/AnimAZEntityNode.h
+++ b/Gems/Maestro/Code/Source/Cinematics/AnimAZEntityNode.h
@@ -57,14 +57,14 @@ public:
 
     void SetPos(float time, const Vec3& pos) override;
     void SetRotate(float time, const Quat& quat) override;
-    void SetScale(float time, const Vec3& scale) override;
+    void SetScale(float time, float scale) override;
 
     Vec3 GetOffsetPosition(const Vec3& position) override;
 
     Vec3 GetPos() override;
     Quat GetRotate() override;
     Quat GetRotate(float time) override;
-    Vec3 GetScale() override;
+    float GetScale() override;
     //////////////////////////////////////////////////////////////////////////
 
     void Serialize(XmlNodeRef& xmlNode, bool bLoading, bool bLoadEmptyTracks);
diff --git a/Gems/Maestro/Code/Source/Cinematics/AnimComponentNode.cpp b/Gems/Maestro/Code/Source/Cinematics/AnimComponentNode.cpp
index ea7322014c..13a5d4ed63 100644
--- a/Gems/Maestro/Code/Source/Cinematics/AnimComponentNode.cpp
+++ b/Gems/Maestro/Code/Source/Cinematics/AnimComponentNode.cpp
@@ -341,10 +341,10 @@ void CAnimComponentNode::ConvertBetweenWorldAndLocalRotation(Quat& rotation, ETr
 }
 
 //////////////////////////////////////////////////////////////////////////
-void CAnimComponentNode::ConvertBetweenWorldAndLocalScale(Vec3& scale, ETransformSpaceConversionDirection conversionDirection) const
+void CAnimComponentNode::ConvertBetweenWorldAndLocalScale(float& scale, ETransformSpaceConversionDirection conversionDirection) const
 {
     AZ::Transform parentTransform = AZ::Transform::Identity();
-    AZ::Transform scaleTransform = AZ::Transform::CreateScale(AZ::Vector3(scale.x, scale.y, scale.z));
+    AZ::Transform scaleTransform = AZ::Transform::CreateUniformScale(scale);
 
     GetParentWorldTransform(parentTransform);
     if (conversionDirection == eTransformConverstionDirection_toLocalSpace)
@@ -353,8 +353,7 @@ void CAnimComponentNode::ConvertBetweenWorldAndLocalScale(Vec3& scale, ETransfor
     }
     scaleTransform = parentTransform * scaleTransform;
 
-    AZ::Vector3 vScale = scaleTransform.GetScale();
-    scale.Set(vScale.GetX(), vScale.GetY(), vScale.GetZ());
+    scale = scaleTransform.GetUniformScale();
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -457,7 +456,7 @@ Quat CAnimComponentNode::GetRotate()
 }
 
 //////////////////////////////////////////////////////////////////////////
-void CAnimComponentNode::SetScale(float time, const Vec3& scale)
+void CAnimComponentNode::SetScale(float time, float scale)
 {
     if (m_componentTypeId == AZ::Uuid(AZ::EditorTransformComponentTypeId) || m_componentTypeId == AzFramework::TransformComponent::TYPEINFO_Uuid())
     {
@@ -468,7 +467,7 @@ void CAnimComponentNode::SetScale(float time, const Vec3& scale)
         {
             // Scale is in World space, even if the entity is parented - because Component Entity AZ::Transforms do not correctly set
             // CBaseObject parenting, so we convert it to Local space here. This should probably be fixed, but for now, we explicitly change from World to Local space here.
-            Vec3 localScale(scale);
+            float localScale = scale;
             ConvertBetweenWorldAndLocalScale(localScale, eTransformConverstionDirection_toLocalSpace);
             scaleTrack->SetValue(time, localScale, bDefault);
         }
@@ -480,15 +479,15 @@ void CAnimComponentNode::SetScale(float time, const Vec3& scale)
     }
 }
 
-Vec3 CAnimComponentNode::GetScale()
+float CAnimComponentNode::GetScale()
 {
     Maestro::SequenceComponentRequests::AnimatablePropertyAddress animatableAddress(m_componentId, "Scale");
-    Maestro::SequenceComponentRequests::AnimatedVector3Value scaleValue(AZ::Vector3::CreateZero());
+    Maestro::SequenceComponentRequests::AnimatedFloatValue scaleValue(0.0f);
     Maestro::SequenceComponentRequestBus::Event(m_pSequence->GetSequenceEntityId(), &Maestro::SequenceComponentRequestBus::Events::GetAnimatedPropertyValue, scaleValue, GetParentAzEntityId(), animatableAddress);
 
     // Always return World scale because Component Entity AZ::Transforms do not correctly set
     // CBaseObject parenting. This should probably be fixed, but for now, we explicitly change from Local to World space here.
-    Vec3 worldScale(scaleValue.GetVector3Value());
+    float worldScale = scaleValue.GetFloatValue();
     ConvertBetweenWorldAndLocalScale(worldScale, eTransformConverstionDirection_toWorldSpace);
 
     return worldScale;
diff --git a/Gems/Maestro/Code/Source/Cinematics/AnimComponentNode.h b/Gems/Maestro/Code/Source/Cinematics/AnimComponentNode.h
index 5d83f7ba0d..48913e5b85 100644
--- a/Gems/Maestro/Code/Source/Cinematics/AnimComponentNode.h
+++ b/Gems/Maestro/Code/Source/Cinematics/AnimComponentNode.h
@@ -71,12 +71,12 @@ public:
 
     void SetPos(float time, const Vec3& pos) override;
     void SetRotate(float time, const Quat& quat) override;
-    void SetScale(float time, const Vec3& scale) override;
+    void SetScale(float time, float scale) override;
 
     Vec3 GetPos() override;
     Quat GetRotate() override;
     Quat GetRotate(float time) override;
-    Vec3 GetScale() override;
+    float GetScale() override;
 
     void Activate(bool bActivate) override;
     //////////////////////////////////////////////////////////////////////////
@@ -128,7 +128,7 @@ private:
     void GetParentWorldTransform(AZ::Transform& retTransform) const;
     void ConvertBetweenWorldAndLocalPosition(Vec3& position, ETransformSpaceConversionDirection conversionDirection) const;
     void ConvertBetweenWorldAndLocalRotation(Quat& rotation, ETransformSpaceConversionDirection conversionDirection) const;
-    void ConvertBetweenWorldAndLocalScale(Vec3& scale, ETransformSpaceConversionDirection conversionDirection) const;
+    void ConvertBetweenWorldAndLocalScale(float& scale, ETransformSpaceConversionDirection conversionDirection) const;
 
     // Utility function to query the units for a track and set the track multiplier if needed. Returns true if track multiplier was set.
     bool SetTrackMultiplier(IAnimTrack* track) const;
diff --git a/Gems/Maestro/Code/Source/Cinematics/AnimNode.h b/Gems/Maestro/Code/Source/Cinematics/AnimNode.h
index 0c52ac5a48..f29ba2eab0 100644
--- a/Gems/Maestro/Code/Source/Cinematics/AnimNode.h
+++ b/Gems/Maestro/Code/Source/Cinematics/AnimNode.h
@@ -79,12 +79,12 @@ public:
     //////////////////////////////////////////////////////////////////////////
     void SetPos([[maybe_unused]] float time, [[maybe_unused]] const Vec3& pos) override {};
     void SetRotate([[maybe_unused]] float time, [[maybe_unused]] const Quat& quat) override {};
-    void SetScale([[maybe_unused]] float time, [[maybe_unused]] const Vec3& scale) override {};
+    void SetScale([[maybe_unused]] float time, [[maybe_unused]] const float scale) override {};
 
     Vec3 GetPos() override { return Vec3(0, 0, 0); };
     Quat GetRotate() override { return Quat(0, 0, 0, 0); };
     Quat GetRotate(float /*time*/) override { return Quat(0, 0, 0, 0); };
-    Vec3 GetScale() override { return Vec3(0, 0, 0); };
+    float GetScale() override { return 0.0f; };
 
     virtual Matrix34 GetReferenceMatrix() const;
 
diff --git a/Gems/PhysX/Code/Source/RigidBodyComponent.cpp b/Gems/PhysX/Code/Source/RigidBodyComponent.cpp
index 8984343fe5..6709412ffe 100644
--- a/Gems/PhysX/Code/Source/RigidBodyComponent.cpp
+++ b/Gems/PhysX/Code/Source/RigidBodyComponent.cpp
@@ -203,9 +203,8 @@ namespace PhysX
             AZ::Quaternion newRotation = AZ::Quaternion::CreateIdentity();
             m_interpolator->GetInterpolated(newPosition, newRotation, deltaTime);
 
-            AZ::Transform interpolatedTransform = AZ::Transform::CreateFromQuaternionAndTranslation(newRotation, newPosition);
-            interpolatedTransform.MultiplyByScale(m_initialScale);
-            AZ::TransformBus::Event(GetEntityId(), &AZ::TransformInterface::SetWorldTM, interpolatedTransform);
+            AZ::TransformBus::Event(GetEntityId(), &AZ::TransformInterface::SetRotationQuaternion, newRotation);
+            AZ::TransformBus::Event(GetEntityId(), &AZ::TransformInterface::SetWorldTranslation, newPosition);
         }
     }
 
@@ -244,14 +243,8 @@ namespace PhysX
         }
         else
         {
-            AZ::Transform transform = m_rigidBody->GetTransform();
-
-            // Maintain scale (this must be precise).
-            AZ::Transform entityTransform = AZ::Transform::Identity();
-            AZ::TransformBus::EventResult(entityTransform, GetEntityId(), &AZ::TransformInterface::GetWorldTM);
-            transform.MultiplyByScale(m_initialScale);
-
-            AZ::TransformBus::Event(GetEntityId(), &AZ::TransformInterface::SetWorldTM, transform);
+            AZ::TransformBus::Event(GetEntityId(), &AZ::TransformInterface::SetRotationQuaternion, m_rigidBody->GetOrientation());
+            AZ::TransformBus::Event(GetEntityId(), &AZ::TransformInterface::SetWorldTranslation, m_rigidBody->GetPosition());
         }
         m_isLastMovementFromKinematicSource = false;
     }
@@ -338,8 +331,6 @@ namespace PhysX
         m_interpolator = std::make_unique<TransformForwardTimeInterpolator>();
         m_interpolator->Reset(transform.GetTranslation(), rotation);
 
-        m_initialScale = transform.ExtractScale();
-
         Physics::RigidBodyNotificationBus::Event(GetEntityId(), &Physics::RigidBodyNotificationBus::Events::OnPhysicsEnabled);
         Physics::WorldBodyNotificationBus::Event(GetEntityId(), &Physics::WorldBodyNotifications::OnPhysicsEnabled);
     }
diff --git a/Gems/PhysX/Code/Source/RigidBodyComponent.h b/Gems/PhysX/Code/Source/RigidBodyComponent.h
index c46e136669..6e5a45ea36 100644
--- a/Gems/PhysX/Code/Source/RigidBodyComponent.h
+++ b/Gems/PhysX/Code/Source/RigidBodyComponent.h
@@ -159,7 +159,6 @@ namespace PhysX
         AzPhysics::RigidBody* m_rigidBody = nullptr;
         AzPhysics::SceneHandle m_attachedSceneHandle = AzPhysics::InvalidSceneHandle;
 
-        AZ::Vector3 m_initialScale = AZ::Vector3::CreateOne();
         bool m_staticTransformAtActivation = false; ///< Whether the transform was static when the component last activated.
         bool m_isLastMovementFromKinematicSource = false; ///< True when the source of the movement comes from SetKinematicTarget as opposed to coming from a Transform change
         bool m_rigidBodyTransformNeedsUpdateOnPhysReEnable = false; ///< True if rigid body transform needs to be synced to the entity's when physics is re-enabled
diff --git a/Gems/PhysX/Code/Source/Utils.cpp b/Gems/PhysX/Code/Source/Utils.cpp
index 767f386b6f..d04db0d37c 100644
--- a/Gems/PhysX/Code/Source/Utils.cpp
+++ b/Gems/PhysX/Code/Source/Utils.cpp
@@ -920,9 +920,9 @@ namespace PhysX
 
         AZ::Vector3 GetTransformScale(AZ::EntityId entityId)
         {
-            AZ::Vector3 worldScale = AZ::Vector3::CreateOne();
-            AZ::TransformBus::EventResult(worldScale, entityId, &AZ::TransformBus::Events::GetWorldScale);
-            return worldScale;
+            float worldScale = 1.0f;
+            AZ::TransformBus::EventResult(worldScale, entityId, &AZ::TransformBus::Events::GetWorldUniformScale);
+            return AZ::Vector3(worldScale);
         }
 
         AZ::Vector3 GetUniformScale(AZ::EntityId entityId)
diff --git a/Gems/PhysX/Code/Tests/ColliderScalingTests.cpp b/Gems/PhysX/Code/Tests/ColliderScalingTests.cpp
index 51a11c7605..5c8fcb70d5 100644
--- a/Gems/PhysX/Code/Tests/ColliderScalingTests.cpp
+++ b/Gems/PhysX/Code/Tests/ColliderScalingTests.cpp
@@ -68,7 +68,7 @@ namespace PhysXEditorTests
 
         AZ::EntityId editorId = editorEntity->GetId();
         AZ::Transform worldTM;
-        worldTM.SetScale(AZ::Vector3(1.5f));
+        worldTM.SetUniformScale(1.5f);
         worldTM.SetTranslation(AZ::Vector3(5.0f, 6.0f, 7.0f));
         worldTM.SetRotation(AZ::Quaternion::CreateRotationX(AZ::DegToRad(30.0f)));
         AZ::TransformBus::Event(editorId, &AZ::TransformBus::Events::SetWorldTM, worldTM);
@@ -99,7 +99,7 @@ namespace PhysXEditorTests
 
         AZ::EntityId editorId = editorEntity->GetId();
         AZ::Transform worldTM;
-        worldTM.SetScale(AZ::Vector3(1.5f));
+        worldTM.SetUniformScale(1.5f);
         worldTM.SetTranslation(AZ::Vector3(5.0f, 6.0f, 7.0f));
         worldTM.SetRotation(AZ::Quaternion::CreateRotationX(AZ::DegToRad(30.0f)));
         AZ::TransformBus::Event(editorId, &AZ::TransformBus::Events::SetWorldTM, worldTM);
@@ -144,7 +144,7 @@ namespace PhysXEditorTests
 
         AZ::EntityId capsuleId = editorEntity->GetId();
         AZ::Transform worldTM;
-        worldTM.SetScale(AZ::Vector3(0.5f));
+        worldTM.SetUniformScale(0.5f);
         worldTM.SetTranslation(AZ::Vector3(3.0f, 1.0f, -4.0f));
         worldTM.SetRotation(AZ::Quaternion::CreateRotationY(AZ::DegToRad(90.0f)));
         AZ::TransformBus::Event(capsuleId, &AZ::TransformBus::Events::SetWorldTM, worldTM);
@@ -176,7 +176,7 @@ namespace PhysXEditorTests
 
         AZ::EntityId capsuleId = editorEntity->GetId();
         AZ::Transform worldTM;
-        worldTM.SetScale(AZ::Vector3(0.5f));
+        worldTM.SetUniformScale(0.5f);
         worldTM.SetTranslation(AZ::Vector3(3.0f, 1.0f, -4.0f));
         worldTM.SetRotation(AZ::Quaternion::CreateRotationY(AZ::DegToRad(90.0f)));
         AZ::TransformBus::Event(capsuleId, &AZ::TransformBus::Events::SetWorldTM, worldTM);
@@ -222,7 +222,7 @@ namespace PhysXEditorTests
 
         AZ::EntityId sphereId = editorEntity->GetId();
         AZ::Transform worldTM;
-        worldTM.SetScale(AZ::Vector3(1.2f));
+        worldTM.SetUniformScale(1.2f);
         worldTM.SetTranslation(AZ::Vector3(-2.0f, -1.0f, 3.0f));
         worldTM.SetRotation(AZ::Quaternion::CreateRotationX(AZ::DegToRad(90.0f)));
         AZ::TransformBus::Event(sphereId, &AZ::TransformBus::Events::SetWorldTM, worldTM);
@@ -254,7 +254,7 @@ namespace PhysXEditorTests
 
         AZ::EntityId sphereId = editorEntity->GetId();
         AZ::Transform worldTM;
-        worldTM.SetScale(AZ::Vector3(1.2f));
+        worldTM.SetUniformScale(1.2f);
         worldTM.SetTranslation(AZ::Vector3(-2.0f, -1.0f, 3.0f));
         worldTM.SetRotation(AZ::Quaternion::CreateRotationX(AZ::DegToRad(90.0f)));
         AZ::TransformBus::Event(sphereId, &AZ::TransformBus::Events::SetWorldTM, worldTM);
diff --git a/Gems/PhysX/Code/Tests/DebugDrawTests.cpp b/Gems/PhysX/Code/Tests/DebugDrawTests.cpp
index 5b41c37f34..610ba8d6f6 100644
--- a/Gems/PhysX/Code/Tests/DebugDrawTests.cpp
+++ b/Gems/PhysX/Code/Tests/DebugDrawTests.cpp
@@ -32,7 +32,7 @@ namespace PhysXEditorTests
 
         AZ::EntityId boxId = boxEntity->GetId();
         AZ::Transform worldTM;
-        worldTM.SetScale(AZ::Vector3(1.5f));
+        worldTM.SetUniformScale(1.5f);
         worldTM.SetTranslation(AZ::Vector3(5.0f, 6.0f, 7.0f));
         worldTM.SetRotation(AZ::Quaternion::CreateRotationX(AZ::DegToRad(30.0f)));
         AZ::TransformBus::Event(boxId, &AZ::TransformBus::Events::SetWorldTM, worldTM);
@@ -61,7 +61,7 @@ namespace PhysXEditorTests
 
         AZ::EntityId boxId = boxEntity->GetId();
         AZ::Transform worldTM;
-        worldTM.SetScale(AZ::Vector3(1.2f));
+        worldTM.SetUniformScale(1.2f);
         worldTM.SetTranslation(AZ::Vector3(4.0f, -3.0f, 1.0f));
         worldTM.SetRotation(AZ::Quaternion::CreateRotationZ(AZ::DegToRad(45.0f)));
         AZ::TransformBus::Event(boxId, &AZ::TransformBus::Events::SetWorldTM, worldTM);
@@ -91,7 +91,7 @@ namespace PhysXEditorTests
 
         AZ::EntityId boxId = boxEntity->GetId();
         AZ::Transform worldTM;
-        worldTM.SetScale(AZ::Vector3(1.2f));
+        worldTM.SetUniformScale(1.2f);
         worldTM.SetTranslation(AZ::Vector3(4.0f, -3.0f, 1.0f));
         worldTM.SetRotation(AZ::Quaternion::CreateRotationZ(AZ::DegToRad(45.0f)));
         AZ::TransformBus::Event(boxId, &AZ::TransformBus::Events::SetWorldTM, worldTM);
@@ -129,7 +129,7 @@ namespace PhysXEditorTests
 
         AZ::EntityId capsuleId = capsuleEntity->GetId();
         AZ::Transform worldTM;
-        worldTM.SetScale(AZ::Vector3(0.5f));
+        worldTM.SetUniformScale(0.5f);
         worldTM.SetTranslation(AZ::Vector3(3.0f, 1.0f, -4.0f));
         worldTM.SetRotation(AZ::Quaternion::CreateRotationY(AZ::DegToRad(90.0f)));
         AZ::TransformBus::Event(capsuleId, &AZ::TransformBus::Events::SetWorldTM, worldTM);
@@ -158,7 +158,7 @@ namespace PhysXEditorTests
 
         AZ::EntityId capsuleId = capsuleEntity->GetId();
         AZ::Transform worldTM;
-        worldTM.SetScale(AZ::Vector3(1.4f));
+        worldTM.SetUniformScale(1.4f);
         worldTM.SetTranslation(AZ::Vector3(1.0f, -4.0f, 4.0f));
         worldTM.SetRotation(AZ::Quaternion::CreateRotationX(AZ::DegToRad(45.0f)));
         AZ::TransformBus::Event(capsuleId, &AZ::TransformBus::Events::SetWorldTM, worldTM);
@@ -189,7 +189,7 @@ namespace PhysXEditorTests
 
         AZ::EntityId sphereId = sphereEntity->GetId();
         AZ::Transform worldTM;
-        worldTM.SetScale(AZ::Vector3(1.2f));
+        worldTM.SetUniformScale(1.2f);
         worldTM.SetTranslation(AZ::Vector3(-2.0f, -1.0f, 3.0f));
         worldTM.SetRotation(AZ::Quaternion::CreateRotationX(AZ::DegToRad(90.0f)));
         AZ::TransformBus::Event(sphereId, &AZ::TransformBus::Events::SetWorldTM, worldTM);
@@ -218,7 +218,7 @@ namespace PhysXEditorTests
 
         AZ::EntityId sphereId = sphereEntity->GetId();
         AZ::Transform worldTM;
-        worldTM.SetScale(AZ::Vector3(0.8f));
+        worldTM.SetUniformScale(0.8f);
         worldTM.SetTranslation(AZ::Vector3(2.0f, -1.0f, 3.0f));
         worldTM.SetRotation(AZ::Quaternion::CreateRotationY(AZ::DegToRad(45.0f)));
         AZ::TransformBus::Event(sphereId, &AZ::TransformBus::Events::SetWorldTM, worldTM);
diff --git a/Gems/PhysX/Code/Tests/RigidBodyComponentTests.cpp b/Gems/PhysX/Code/Tests/RigidBodyComponentTests.cpp
index eee747d390..4ff88c0b3b 100644
--- a/Gems/PhysX/Code/Tests/RigidBodyComponentTests.cpp
+++ b/Gems/PhysX/Code/Tests/RigidBodyComponentTests.cpp
@@ -38,8 +38,8 @@ namespace PhysXEditorTests
         const AZ::Aabb originalAabb = rigidBodyComponent->GetRigidBody()->GetAabb();
 
         // Update the scale
-        const AZ::Vector3 scale(2.0f);
-        AZ::TransformBus::Event(editorEntity->GetId(), &AZ::TransformInterface::SetLocalScale, scale);
+        float scale = 2.0f;
+        AZ::TransformBus::Event(editorEntity->GetId(), &AZ::TransformInterface::SetLocalUniformScale, scale);
 
         // Trigger editor physics world update so EditorRigidBodyComponent can process scale change
         auto* physicsSystem = AZ::Interface<AzPhysics::SystemInterface>::Get();
@@ -89,8 +89,8 @@ namespace PhysXEditorTests
             idPair, &PhysX::EditorColliderComponentRequests::SetColliderOffset, offset);
 
         // Update the scale
-        const AZ::Vector3 scale(2.0f);
-        AZ::TransformBus::Event(editorEntity->GetId(), &AZ::TransformInterface::SetLocalScale, scale);
+        float scale = 2.0f;
+        AZ::TransformBus::Event(editorEntity->GetId(), &AZ::TransformInterface::SetLocalUniformScale, scale);
 
         // Update editor world to let updates to be applied
         physicsSystem->Simulate(0.1f);
diff --git a/Gems/PhysX/Code/Tests/ShapeColliderComponentTests.cpp b/Gems/PhysX/Code/Tests/ShapeColliderComponentTests.cpp
index 8af9defff8..ad632b579d 100644
--- a/Gems/PhysX/Code/Tests/ShapeColliderComponentTests.cpp
+++ b/Gems/PhysX/Code/Tests/ShapeColliderComponentTests.cpp
@@ -241,7 +241,7 @@ namespace PhysXEditorTests
         SetPolygonPrismHeight(entityId, 2.0f);
 
         // update the transform scale and non-uniform scale
-        AZ::TransformBus::Event(entityId, &AZ::TransformBus::Events::SetLocalScale, AZ::Vector3(2.0f));
+        AZ::TransformBus::Event(entityId, &AZ::TransformBus::Events::SetLocalUniformScale, 2.0f);
         AZ::NonUniformScaleRequestBus::Event(entityId, &AZ::NonUniformScaleRequests::SetScale, AZ::Vector3(0.5f, 1.5f, 2.0f));
 
         EntityPtr gameEntity = CreateActiveGameEntityFromEditorEntity(editorEntity.get());
@@ -435,8 +435,8 @@ namespace PhysXEditorTests
             &LmbrCentral::BoxShapeComponentRequests::GetBoxDimensions);
 
         // update the transform
-        const AZ::Vector3 scale(2.0f);
-        AZ::TransformBus::Event(editorEntityId, &AZ::TransformInterface::SetLocalScale, scale);
+        const float scale = 2.0f;
+        AZ::TransformBus::Event(editorEntityId, &AZ::TransformInterface::SetLocalUniformScale, scale);
         const AZ::Vector3 translation(10.0f, 20.0f, 30.0f);
         AZ::TransformBus::Event(editorEntityId, &AZ::TransformInterface::SetWorldTranslation, translation);
 
@@ -527,10 +527,8 @@ namespace PhysXEditorTests
         editorParentEntity->Activate();
 
         // set some scale to parent entity
-        const AZ::Vector3 parentScale(2.0f);
-        AZ::TransformBus::Event(editorParentEntity->GetId(),
-            &AZ::TransformInterface::SetLocalScale,
-            parentScale);
+        const float parentScale = 2.0f;
+        AZ::TransformBus::Event(editorParentEntity->GetId(), &AZ::TransformInterface::SetLocalUniformScale, parentScale);
 
         // create an editor child entity with a shape collider component and a box shape component
         EntityPtr editorChildEntity = CreateInactiveEditorEntity("ChildEntity");
diff --git a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Datum.cpp b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Datum.cpp
index a0db02c3a8..30e55cee49 100644
--- a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Datum.cpp
+++ b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Datum.cpp
@@ -2527,15 +2527,15 @@ namespace ScriptCanvas
     {
         Data::TransformType copy(source);
         AZ::Vector3 pos = copy.GetTranslation();
-        AZ::Vector3 scale = copy.ExtractScale();
+        float scale = copy.ExtractUniformScale();
         AZ::Vector3 rotation = AZ::ConvertTransformToEulerDegrees(copy);
         return AZStd::string::format
              ( "(Position: X: %f, Y: %f, Z: %f,"
                " Rotation: X: %f, Y: %f, Z: %f,"
-               " Scale: X: %f, Y: %f, Z: %f)"
+               " Scale: %f)"
              , static_cast<float>(pos.GetX()), static_cast<float>(pos.GetY()), static_cast<float>(pos.GetZ())
              , static_cast<float>(rotation.GetX()), static_cast<float>(rotation.GetY()), static_cast<float>(rotation.GetZ())
-             , static_cast<float>(scale.GetX()), static_cast<float>(scale.GetY()), static_cast<float>(scale.GetZ()));
+             , scale);
     }
 
     AZStd::string Datum::ToStringVector2(const AZ::Vector2& source) const
diff --git a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Entity/Rotate.cpp b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Entity/Rotate.cpp
index c510b55314..2f79d4218a 100644
--- a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Entity/Rotate.cpp
+++ b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Entity/Rotate.cpp
@@ -47,21 +47,10 @@ namespace ScriptCanvas
 
                         AZ::Transform currentTransform = AZ::Transform::CreateIdentity();
                         AZ::TransformBus::EventResult(currentTransform, targetEntity, &AZ::TransformInterface::GetWorldTM);
-                        
-                        AZ::Vector3 position = currentTransform.GetTranslation();
 
-                        AZ::Quaternion currentRotation = currentTransform.GetRotation();
+                        currentTransform.SetRotation((rotation * currentTransform.GetRotation().GetNormalized()));
 
-                        AZ::Quaternion newRotation = (rotation * currentRotation);
-                        newRotation.Normalize();
-
-                        AZ::Transform newTransform = AZ::Transform::CreateIdentity();
-
-                        newTransform.SetScale(currentTransform.GetScale());
-                        newTransform.SetRotation(newRotation);
-                        newTransform.SetTranslation(position);
-
-                        AZ::TransformBus::Event(targetEntity, &AZ::TransformInterface::SetWorldTM, newTransform);
+                        AZ::TransformBus::Event(targetEntity, &AZ::TransformInterface::SetWorldTM, currentTransform);
                     }
                 }
 
diff --git a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Entity/RotateMethod.cpp b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Entity/RotateMethod.cpp
index 20ea4e1b33..53884f4dd8 100644
--- a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Entity/RotateMethod.cpp
+++ b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Entity/RotateMethod.cpp
@@ -44,22 +44,12 @@ namespace ScriptCanvas
                 {
                     AZ::Quaternion rotation = AZ::ConvertEulerDegreesToQuaternion(angles);
 
-                    AZ::Transform currentTransform = AZ::Transform::CreateIdentity();
-                    AZ::TransformBus::EventResult(currentTransform, targetEntity, &AZ::TransformInterface::GetWorldTM);
+                    AZ::Transform transform = AZ::Transform::CreateIdentity();
+                    AZ::TransformBus::EventResult(transform, targetEntity, &AZ::TransformInterface::GetWorldTM);
 
-                    AZ::Vector3 position = currentTransform.GetTranslation();
-                    AZ::Quaternion currentRotation = currentTransform.GetRotation();
+                    transform.SetRotation((rotation * transform.GetRotation()).GetNormalized());
 
-                    AZ::Quaternion newRotation = (rotation * currentRotation);
-                    newRotation.Normalize();
-
-                    AZ::Transform newTransform = AZ::Transform::CreateIdentity();
-
-                    newTransform.CreateScale(currentTransform.ExtractScale());
-                    newTransform.SetRotation(newRotation);
-                    newTransform.SetTranslation(position);
-
-                    AZ::TransformBus::Event(targetEntity, &AZ::TransformInterface::SetWorldTM, newTransform);
+                    AZ::TransformBus::Event(targetEntity, &AZ::TransformInterface::SetWorldTM, transform);
                 }
             }
         }
diff --git a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Math/TransformNodes.h b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Math/TransformNodes.h
index 6a0f082272..7aafdf584e 100644
--- a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Math/TransformNodes.h
+++ b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Math/TransformNodes.h
@@ -26,9 +26,9 @@ namespace ScriptCanvas
         using namespace MathNodeUtilities;
         static const char* k_categoryName = "Math/Transform";
 
-        AZ_INLINE std::tuple<Vector3Type, TransformType> ExtractScale(TransformType source)
+        AZ_INLINE std::tuple<NumberType, TransformType> ExtractScale(TransformType source)
         {
-            auto scale(source.ExtractScale());
+            auto scale(source.ExtractUniformScale());
             return std::make_tuple( scale, source );
         }
         SCRIPT_CANVAS_GENERIC_FUNCTION_MULTI_RESULTS_NODE(ExtractScale, k_categoryName, "{8DFE5247-0950-4CD1-87E6-0CAAD42F1637}", "returns a vector which is the length of the scale components, and a transform with the scale extracted ", "Source", "Scale", "Extracted");
diff --git a/Gems/StartingPointCamera/Code/Source/CameraLookAtBehaviors/RotateCameraLookAt.cpp b/Gems/StartingPointCamera/Code/Source/CameraLookAtBehaviors/RotateCameraLookAt.cpp
index 2ab7e0bd01..e2e818f3e7 100644
--- a/Gems/StartingPointCamera/Code/Source/CameraLookAtBehaviors/RotateCameraLookAt.cpp
+++ b/Gems/StartingPointCamera/Code/Source/CameraLookAtBehaviors/RotateCameraLookAt.cpp
@@ -58,19 +58,9 @@ namespace Camera
         float axisPolarity = m_shouldInvertAxis ? -1.0f : 1.0f;
         float rotationAmount = axisPolarity * m_rotationAmount;
 
-        // remove translation and scale
-        AZ::Vector3 translation = outLookAtTargetTransform.GetTranslation();
-        outLookAtTargetTransform.SetTranslation(AZ::Vector3::CreateZero());
-        AZ::Vector3 transformScale = outLookAtTargetTransform.ExtractScale();
-
-        // perform our rotation
-        AZ::Transform desiredRotationTransform = AZ::Transform::CreateFromQuaternion(AZ::Quaternion::CreateFromAxisAngle(outLookAtTargetTransform.GetBasis(m_axisOfRotation), rotationAmount));
-
-        outLookAtTargetTransform = desiredRotationTransform * outLookAtTargetTransform;
-
-        // return scale and translate
-        outLookAtTargetTransform.SetScale(transformScale);
-        outLookAtTargetTransform.SetTranslation(translation);
+        AZ::Quaternion desiredRotation = AZ::Quaternion::CreateFromAxisAngle(
+            outLookAtTargetTransform.GetBasis(m_axisOfRotation), rotationAmount);
+        outLookAtTargetTransform.SetRotation(desiredRotation * outLookAtTargetTransform.GetRotation());
     }
 
     void RotateCameraLookAt::Activate(AZ::EntityId entityId)