How can transaction management be performed independently, without relying on built-in database or system tools?

To manage transactions independently without relying on built-in database or system tools, you can implement the Unit of Work pattern or use a custom change logging and rollback mechanism.

Main steps:

1. Local change storage: All operations that should be part of a transaction are first stored in a data structure (e.g., a list of commands or changes), but not immediately applied to the database.

2. Commit: Upon successful completion of all operations, changes are applied to the database or other storage.

3. Rollback: If an error occurs, changes are not applied, or a reverse operation is performed to undo already made changes.

Example in Python using the Unit of Work pattern:

class UnitOfWork:
    def __init__(self):
        self.new_objects = []
        self.dirty_objects = []
        self.removed_objects = []

    def register_new(self, obj):
        self.new_objects.append(obj)

    def register_dirty(self, obj):
        self.dirty_objects.append(obj)

    def register_removed(self, obj):
        self.removed_objects.append(obj)

    def commit(self):
        try:
            for obj in self.new_objects:
                obj.insert()
            for obj in self.dirty_objects:
                obj.update()
            for obj in self.removed_objects:
                obj.delete()
        except Exception as e:
            self.rollback()
            raise e

    def rollback(self):
        # Rollback implementation depends on context
        self.new_objects.clear()
        self.dirty_objects.clear()
        self.removed_objects.clear()

Thus, you control exactly when changes are applied and can roll them back if necessary, without relying on built-in transaction mechanisms.