diff --git a/Code/Light.SharedCore/DatabaseAccessAbstractions/IAsyncReadOnlySession.cs b/Code/Light.SharedCore/DatabaseAccessAbstractions/IAsyncReadOnlySession.cs
deleted file mode 100644
index 6273c5e..0000000
--- a/Code/Light.SharedCore/DatabaseAccessAbstractions/IAsyncReadOnlySession.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-using System;
-
-namespace Light.SharedCore.DatabaseAccessAbstractions;
-
-/// <summary>
-/// Represents an asynchronous session to the database that
-/// is only used to read data. This usually means that no explicit
-/// transaction is needed for this session, although implementations can support
-/// it to allow using READ UNCOMMITED isolation levels for queries, for example.
-/// The connection to the database can be terminated by calling
-/// <see cref="IAsyncDisposable.DisposeAsync" /> (or <see cref="IDisposable.Dispose" />).
-/// If you want to manipulate data, use <see cref="IAsyncSession" />.
-/// </summary>
-/// <remarks>
-/// Conceptually, a session is identical to a "Unit of Work" as defined in "Patterns of
-/// Enterprise Application Architecture" by Martin Fowler et al. It manages the connection
-/// to the database and represents a transaction. Strictly speaking, a Unit of Work also needs
-/// to do Change Tracking which plain ADO.NET and all Micro-ORMs do not support. For this reason,
-/// we chose the term "session" instead of "Unit of Work", also because it is simpler to use in daily life.
-/// </remarks>
-public interface IAsyncReadOnlySession : IDisposable, IAsyncDisposable;
\ No newline at end of file
diff --git a/Code/Light.SharedCore/DatabaseAccessAbstractions/IAsyncSession.cs b/Code/Light.SharedCore/DatabaseAccessAbstractions/IAsyncSession.cs
deleted file mode 100644
index 32c7564..0000000
--- a/Code/Light.SharedCore/DatabaseAccessAbstractions/IAsyncSession.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace Light.SharedCore.DatabaseAccessAbstractions;
-
-/// <summary>
-/// Represents an asynchronous session to a database that manipulates data. This means that
-/// the implementation will either use a single dedicated transaction in the case of ADO.NET or Micro-ORMs
-/// to ensure ACID properties, or the Change Tracking capabilities of a full ORM like Entity Framework Core.
-/// The connection to the database can be terminated by calling
-/// <see cref="IAsyncDisposable.DisposeAsync" /> (or <see cref="IDisposable.Dispose" />), the underlying transaction
-/// will be automatically rolled back if <see cref="SaveChangesAsync"/> was not called beforehand.
-/// Changes can be saved or committed to the database by calling <see cref="SaveChangesAsync" />.
-/// If your session does not manipulate data, consider using the <see cref="IAsyncReadOnlySession" /> interface instead.
-/// </summary>
-/// <remarks>
-/// Conceptually, a session is identical to a "Unit of Work" as defined in "Patterns of
-/// Enterprise Application Architecture" by Martin Fowler et al. It manages the connection
-/// to the database and represents a transaction. Strictly speaking, a Unit of Work also needs
-/// to do Change Tracking which plain ADO.NET and all Micro-ORMs do not support. For this reason,
-/// we chose the term "session" instead of "Unit of Work", also because it is simpler to use in daily life.
-/// </remarks>
-public interface IAsyncSession : IAsyncReadOnlySession
-{
-    /// <summary>
-    /// Commits all changes to the database.
-    /// </summary>
-    /// <param name="cancellationToken">The token to cancel this asynchronous operation (optional).</param>
-    Task SaveChangesAsync(CancellationToken cancellationToken = default);
-}
\ No newline at end of file
diff --git a/Code/Light.SharedCore/DatabaseAccessAbstractions/IAsyncTransaction.cs b/Code/Light.SharedCore/DatabaseAccessAbstractions/IAsyncTransaction.cs
deleted file mode 100644
index e8ad148..0000000
--- a/Code/Light.SharedCore/DatabaseAccessAbstractions/IAsyncTransaction.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace Light.SharedCore.DatabaseAccessAbstractions;
-
-/// <summary>
-/// Represents an asynchronous transaction that can be committed. The transaction should always be disposed.
-/// A rollback is performed automatically on <see cref="IAsyncDisposable.DisposeAsync" /> when <see cref="CommitAsync"/> was not
-/// called beforehand.
-/// </summary>
-public interface IAsyncTransaction : IAsyncDisposable, IDisposable
-{
-    /// <summary>
-    /// Commits the changes made during this transaction to the database.
-    /// </summary>
-    /// <param name="cancellationToken">The token to cancel this asynchronous operation (optional).</param>
-    Task CommitAsync(CancellationToken cancellationToken = default);
-}
\ No newline at end of file
diff --git a/Code/Light.SharedCore/DatabaseAccessAbstractions/IAsyncTransactionalSession.cs b/Code/Light.SharedCore/DatabaseAccessAbstractions/IAsyncTransactionalSession.cs
deleted file mode 100644
index 4049993..0000000
--- a/Code/Light.SharedCore/DatabaseAccessAbstractions/IAsyncTransactionalSession.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace Light.SharedCore.DatabaseAccessAbstractions;
-
-/// <summary>
-/// Represents an asynchronous session to a database that is able to create individual transactions.
-/// The connection to the database can be terminated by calling <see cref="IAsyncDisposable.DisposeAsync" />.
-/// Changes can be committed by first creating a transaction using <see cref="BeginTransactionAsync" />
-/// and later committing this transaction.
-/// PLEASE REMEMBER: when your connection to the database always uses a single transaction, please
-/// consider using the <see cref="IAsyncSession" /> interface instead. Avoid nesting of several transactions
-/// as the interfaces in this package do not cover trees of transactions.
-/// </summary>
-public interface IAsyncTransactionalSession : IAsyncReadOnlySession
-{
-    /// <summary>
-    /// Creates a new transaction. Please ensure not to call this method while another transaction
-    /// is still active in your current scope (to avoid nesting transactions).
-    /// </summary>
-    /// <param name="cancellationToken">The token to cancel this asynchronous operation (optional).</param>
-    ValueTask<IAsyncTransaction> BeginTransactionAsync(CancellationToken cancellationToken = default);
-}
\ No newline at end of file
diff --git a/Code/Light.SharedCore/DatabaseAccessAbstractions/ISession.cs b/Code/Light.SharedCore/DatabaseAccessAbstractions/ISession.cs
index 8b86dc9..9f90f11 100644
--- a/Code/Light.SharedCore/DatabaseAccessAbstractions/ISession.cs
+++ b/Code/Light.SharedCore/DatabaseAccessAbstractions/ISession.cs
@@ -1,22 +1,23 @@
 using System;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace Light.SharedCore.DatabaseAccessAbstractions;
 
 /// <summary>
 /// <para>
-/// PLEASE REMEMBER: database calls should be performed asynchronously
-/// by default, especially in service apps to avoid blocking threads.
-/// Consider using the <see cref="IAsyncSession" /> interface instead.
+/// Represents the base interface for an asynchronous session to a database that manipulates data. This means that
+/// the implementation will either use a single dedicated transaction in the case of ADO.NET or Micro-ORMs
+/// to ensure ACID properties, or the change tracking capabilities of a full ORM like Entity Framework Core.
 /// </para>
 /// <para>
-/// Represents a synchronous session to a database. This means that
-/// the implementation will either use a single dedicated transaction in the case of ADO.NET or Micro-ORMs
-/// to ensure ACID properties, or the Change Tracking capabilities of a full ORM like Entity Framework Core. The
-/// connection to the database can be terminated by calling
-/// <see cref="IDisposable.Dispose" />. Changes can be saved or committed
-/// to the database by calling <see cref="SaveChanges" />.
-/// If your session does not manipulate data, consider deriving your session abstraction from
-/// the <see cref="IDisposable" /> interface instead.
+/// The connection to the database can be terminated by calling
+/// <see cref="IAsyncDisposable.DisposeAsync" />, the underlying transaction
+/// will be automatically rolled back if <see cref="SaveChangesAsync" /> was not called beforehand.
+/// </para>
+/// <para>
+/// If you don't want the caller to explicitly commit the changes, consider deriving your session from
+/// <see cref="IAsyncDisposable"/> directly. 
 /// </para>
 /// </summary>
 /// <remarks>
@@ -26,10 +27,11 @@ namespace Light.SharedCore.DatabaseAccessAbstractions;
 /// to do Change Tracking which plain ADO.NET and all Micro-ORMs do not support. For this reason,
 /// we chose the term "session" instead of "Unit of Work", also because it is simpler to use in daily life.
 /// </remarks>
-public interface ISession : IDisposable
+public interface ISession : IAsyncDisposable
 {
     /// <summary>
-    /// Writes or commits all changes that occurred during the session to the target database.
+    /// Commits all changes to the database.
     /// </summary>
-    void SaveChanges();
+    /// <param name="cancellationToken">The token to cancel this asynchronous operation (optional).</param>
+    Task SaveChangesAsync(CancellationToken cancellationToken = default);
 }
\ No newline at end of file
diff --git a/Code/Light.SharedCore/DatabaseAccessAbstractions/ITransaction.cs b/Code/Light.SharedCore/DatabaseAccessAbstractions/ITransaction.cs
deleted file mode 100644
index cae41c4..0000000
--- a/Code/Light.SharedCore/DatabaseAccessAbstractions/ITransaction.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-using System;
-
-namespace Light.SharedCore.DatabaseAccessAbstractions;
-
-/// <summary>
-/// <para>
-/// PLEASE REMEMBER: database calls should be performed asynchronously
-/// by default, especially in service apps to avoid blocking threads.
-/// Consider using <see cref="IAsyncTransaction" /> instead.
-/// </para>
-/// <para>
-/// Represents a synchronous transaction that can be committed. The transaction should always be disposed.
-/// A rollback is performed automatically on <see cref="IDisposable.Dispose" /> when commit was not called
-/// beforehand.
-/// </para>
-/// </summary>
-public interface ITransaction : IDisposable
-{
-    /// <summary>
-    /// Commits the changes made during this transaction to the database.
-    /// </summary>
-    void Commit();
-}
\ No newline at end of file
diff --git a/Code/Light.SharedCore/DatabaseAccessAbstractions/ITransactionalSession.cs b/Code/Light.SharedCore/DatabaseAccessAbstractions/ITransactionalSession.cs
deleted file mode 100644
index dc5b69f..0000000
--- a/Code/Light.SharedCore/DatabaseAccessAbstractions/ITransactionalSession.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-using System;
-
-namespace Light.SharedCore.DatabaseAccessAbstractions;
-
-/// <summary>
-/// <para>
-/// PLEASE REMEMBER: database calls should be performed asynchronously
-/// by default, especially in service apps to avoid blocking threads. Consider using the
-/// <see cref="IAsyncTransactionalSession" /> instead. Furthermore, when your connection to the
-/// database always uses a single transaction, please consider using the <see cref="IAsyncSession" />
-/// or <see cref="ISession" /> interfaces instead.
-/// </para>
-/// <para>
-/// Represents a synchronous session to a database that is able to create individual transactions.
-/// The connection to the database can be terminated by calling <see cref="IDisposable.Dispose" />.
-/// Changes can be committed by first creating a transaction using <see cref="BeginTransaction" />
-/// and later committing this transaction.
-/// Avoid nesting of several transactions as the interfaces
-/// in this package do not cover trees of transactions.
-/// </para>
-/// </summary>
-public interface ITransactionalSession : IDisposable
-{
-    /// <summary>
-    /// Creates a new transaction. Please ensure not to call this method while another transaction
-    /// is still active in your current scope (to avoid nesting transactions).
-    /// </summary>
-    ITransaction BeginTransaction();
-}
\ No newline at end of file