diff --git a/src/main/java/com/devcycle/sdk/server/cloud/api/DevCycleCloudClient.java b/src/main/java/com/devcycle/sdk/server/cloud/api/DevCycleCloudClient.java
index c45e3b01..9f9297a3 100755
--- a/src/main/java/com/devcycle/sdk/server/cloud/api/DevCycleCloudClient.java
+++ b/src/main/java/com/devcycle/sdk/server/cloud/api/DevCycleCloudClient.java
@@ -3,6 +3,8 @@
 import com.devcycle.sdk.server.cloud.model.DevCycleCloudOptions;
 import com.devcycle.sdk.server.common.api.IDevCycleApi;
 import com.devcycle.sdk.server.common.api.IDevCycleClient;
+import com.devcycle.sdk.server.common.exception.AfterHookError;
+import com.devcycle.sdk.server.common.exception.BeforeHookError;
 import com.devcycle.sdk.server.common.exception.DevCycleException;
 import com.devcycle.sdk.server.common.logging.DevCycleLogger;
 import com.devcycle.sdk.server.common.model.*;
@@ -17,9 +19,7 @@
 import retrofit2.Response;
 
 import java.io.IOException;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
+import java.util.*;
 
 public final class DevCycleCloudClient implements IDevCycleClient {
 
@@ -27,6 +27,7 @@ public final class DevCycleCloudClient implements IDevCycleClient {
     private final IDevCycleApi api;
     private final DevCycleCloudOptions dvcOptions;
     private final DevCycleProvider openFeatureProvider;
+    private final EvalHooksRunner evalHooksRunner;
 
     public DevCycleCloudClient(String sdkKey) {
         this(sdkKey, DevCycleCloudOptions.builder().build());
@@ -50,6 +51,7 @@ public DevCycleCloudClient(String sdkKey, DevCycleCloudOptions options) {
         OBJECT_MAPPER.setSerializationInclusion(JsonInclude.Include.NON_NULL);
 
         this.openFeatureProvider = new DevCycleProvider(this);
+        this.evalHooksRunner = new EvalHooksRunner();
     }
 
     /**
@@ -109,23 +111,46 @@ public <T> Variable<T> variable(DevCycleUser user, String key, T defaultValue) {
         }
 
         TypeEnum variableType = TypeEnum.fromClass(defaultValue.getClass());
-        Variable<T> variable;
+        Variable<T> variable = null;
+        HookContext<T> context = new HookContext<T>(user, key, defaultValue);
+        ArrayList<EvalHook<T>> hooks = new ArrayList<EvalHook<T>>(evalHooksRunner.getHooks());
+        ArrayList<EvalHook<T>> reversedHooks = new ArrayList<>(hooks);
+        Collections.reverse(reversedHooks);
 
         try {
+            Throwable beforeError = null;
+
+            try {
+                context = context.merge(evalHooksRunner.executeBefore(hooks, context));
+            } catch (Throwable e) {
+                beforeError = e;
+            }
+
             Call<Variable> response = api.getVariableByKey(user, key, dvcOptions.getEnableEdgeDB());
             variable = getResponseWithRetries(response, 5);
             if (variable.getType() != variableType) {
                 throw new IllegalArgumentException("Variable type mismatch, returning default value");
             }
+            if (beforeError != null) {
+                throw beforeError;
+            }
+
+            evalHooksRunner.executeAfter(reversedHooks, context, variable);
             variable.setIsDefaulted(false);
-        } catch (Exception exception) {
-            variable = (Variable<T>) Variable.builder()
-                    .key(key)
-                    .type(variableType)
-                    .value(defaultValue)
-                    .defaultValue(defaultValue)
-                    .isDefaulted(true)
-                    .build();
+        } catch (Throwable exception) {
+            if (!(exception instanceof BeforeHookError || exception instanceof AfterHookError)) {
+                variable = (Variable<T>) Variable.builder()
+                        .key(key)
+                        .type(variableType)
+                        .value(defaultValue)
+                        .defaultValue(defaultValue)
+                        .isDefaulted(true)
+                        .build();
+            }
+
+            evalHooksRunner.executeError(reversedHooks, context, exception);
+        } finally {
+            evalHooksRunner.executeFinally(reversedHooks, context, Optional.ofNullable(variable));
         }
         return variable;
     }
@@ -226,6 +251,13 @@ private <T> T getResponseWithRetries(Call<T> call, int maxRetries) throws DevCyc
         throw new DevCycleException(HttpResponseCode.SERVER_ERROR, errorResponse);
     }
 
+    public void addHook(EvalHook hook) {
+        this.evalHooksRunner.addHook(hook);
+    }
+
+    public void clearHooks() {
+        this.evalHooksRunner.clearHooks();
+    }
 
     private <T> T getResponse(Call<T> call) throws DevCycleException {
         ErrorResponse errorResponse = ErrorResponse.builder().build();
diff --git a/src/main/java/com/devcycle/sdk/server/common/exception/AfterHookError.java b/src/main/java/com/devcycle/sdk/server/common/exception/AfterHookError.java
new file mode 100644
index 00000000..9be07e5e
--- /dev/null
+++ b/src/main/java/com/devcycle/sdk/server/common/exception/AfterHookError.java
@@ -0,0 +1,14 @@
+package com.devcycle.sdk.server.common.exception;
+
+/**
+ * Exception thrown when an after hook fails during variable evaluation.
+ */
+public class AfterHookError extends RuntimeException {
+    public AfterHookError(String message) {
+        super(message);
+    }
+
+    public AfterHookError(String message, Throwable cause) {
+        super(message, cause);
+    }
+} 
\ No newline at end of file
diff --git a/src/main/java/com/devcycle/sdk/server/common/exception/BeforeHookError.java b/src/main/java/com/devcycle/sdk/server/common/exception/BeforeHookError.java
new file mode 100644
index 00000000..bd595ee6
--- /dev/null
+++ b/src/main/java/com/devcycle/sdk/server/common/exception/BeforeHookError.java
@@ -0,0 +1,14 @@
+package com.devcycle.sdk.server.common.exception;
+
+/**
+ * Exception thrown when a before hook fails during variable evaluation.
+ */
+public class BeforeHookError extends RuntimeException {
+    public BeforeHookError(String message) {
+        super(message);
+    }
+
+    public BeforeHookError(String message, Throwable cause) {
+        super(message, cause);
+    }
+} 
\ No newline at end of file
diff --git a/src/main/java/com/devcycle/sdk/server/common/model/EvalHook.java b/src/main/java/com/devcycle/sdk/server/common/model/EvalHook.java
new file mode 100644
index 00000000..066a94b7
--- /dev/null
+++ b/src/main/java/com/devcycle/sdk/server/common/model/EvalHook.java
@@ -0,0 +1,13 @@
+package com.devcycle.sdk.server.common.model;
+
+import java.util.Optional;
+
+public interface EvalHook<T> {
+
+    default Optional<HookContext<T>> before(HookContext<T> ctx) {
+        return Optional.empty();
+    }
+    default void after(HookContext<T> ctx, Variable<T> variable) {}
+    default void error(HookContext<T> ctx, Throwable e) {}
+    default void onFinally(HookContext<T> ctx, Optional<Variable<T>> variable) {}
+}
\ No newline at end of file
diff --git a/src/main/java/com/devcycle/sdk/server/common/model/EvalHooksRunner.java b/src/main/java/com/devcycle/sdk/server/common/model/EvalHooksRunner.java
new file mode 100644
index 00000000..3a25d6e0
--- /dev/null
+++ b/src/main/java/com/devcycle/sdk/server/common/model/EvalHooksRunner.java
@@ -0,0 +1,120 @@
+package com.devcycle.sdk.server.common.model;
+
+import com.devcycle.sdk.server.common.exception.AfterHookError;
+import com.devcycle.sdk.server.common.exception.BeforeHookError;
+import com.devcycle.sdk.server.common.logging.DevCycleLogger;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * A class that manages evaluation hooks for the DevCycle SDK.
+ * Provides functionality to add and clear hooks, storing them in an array.
+ */
+public class EvalHooksRunner<T> {
+    private List<EvalHook<T>> hooks;
+
+    /**
+     * Default constructor initializes an empty list of hooks.
+     */
+    public EvalHooksRunner() {
+        this.hooks = new ArrayList<>();
+    }
+
+    /**
+     * Adds a single hook to the collection.
+     * 
+     * @param hook The hook to add
+     */
+    public void addHook(EvalHook<T> hook) {
+        if (hook != null) {
+            hooks.add(hook);
+        }
+    }
+
+    /**
+     * Clears all hooks from the collection.
+     */
+    public void clearHooks() {
+        hooks.clear();
+    }
+
+    public List<EvalHook<T>> getHooks() {
+        return this.hooks;
+    }
+
+    /**
+     * Runs all before hooks in order.
+     *
+     * @param context The context to pass to the hooks
+     * @param <T> The type of the variable value
+     * @return The potentially modified context
+     */
+    public <T> HookContext<T> executeBefore(ArrayList<EvalHook<T>> hooks, HookContext<T> context) {
+        HookContext<T> beforeContext = context;
+        for (EvalHook<T> hook : hooks) {
+            try {
+                Optional<HookContext<T>> newContext = hook.before(beforeContext);
+                if (newContext.isPresent()) {
+                    beforeContext = beforeContext.merge(newContext.get());
+                }
+            } catch (Exception e) {
+                throw new BeforeHookError("Before hook failed", e);
+            }
+        }
+        return beforeContext;
+    }
+
+    /**
+     * Runs all after hooks in reverse order.
+     *
+     * @param context The context to pass to the hooks
+     * @param variable The variable result to pass to the hooks
+     * @param <T> The type of the variable value
+     */
+    public void executeAfter(ArrayList<EvalHook<T>> hooks, HookContext<T> context, Variable<T> variable) {
+        for (EvalHook<T> hook : hooks) {
+            try {
+                hook.after(context, variable);
+            } catch (Exception e) {
+                throw new AfterHookError("After hook failed", e);
+            }
+        }
+    }
+
+    /**
+     * Runs all error hooks in reverse order.
+     *
+     * @param context The context to pass to the hooks
+     * @param error The error that occurred
+     * @param <T> The type of the variable value
+     */
+    public void executeError(ArrayList<EvalHook<T>> hooks, HookContext<T> context, Throwable error) {
+        for (EvalHook<T> hook : hooks) {
+            try {
+                hook.error(context, error);
+            } catch (Exception hookError) {
+                // Log hook error but don't throw to avoid masking the original error
+                DevCycleLogger.error("Error hook failed: " + hookError.getMessage(), hookError);
+            }
+        }
+    }
+
+    /**
+     * Runs all finally hooks in reverse order.
+     * 
+     * @param context The context to pass to the hooks
+     * @param variable The variable result to pass to the hooks (may be null)
+     */
+    public void executeFinally(ArrayList<EvalHook<T>> hooks, HookContext<T> context, Optional<Variable<T>> variable) {
+        for (EvalHook<T> hook : hooks) {
+            try {
+                hook.onFinally(context, variable);
+            } catch (Exception e) {
+                // Log finally hook error but don't throw
+                DevCycleLogger.error("Finally hook failed: " + e.getMessage(), e);
+            }
+        }
+    }
+}
diff --git a/src/main/java/com/devcycle/sdk/server/common/model/HookContext.java b/src/main/java/com/devcycle/sdk/server/common/model/HookContext.java
new file mode 100644
index 00000000..320a71f6
--- /dev/null
+++ b/src/main/java/com/devcycle/sdk/server/common/model/HookContext.java
@@ -0,0 +1,48 @@
+package com.devcycle.sdk.server.common.model;
+
+import java.util.Map;
+
+/**
+ * Context object passed to hooks during variable evaluation.
+ * Contains the user, variable key, default value, and additional context data.
+ */
+public class HookContext<T> {
+    private DevCycleUser user;
+    private final String key;
+    private final T defaultValue;
+    private Variable<T> variableDetails;
+
+    public HookContext(DevCycleUser user, String key, T defaultValue) {
+        this.user = user;
+        this.key = key;
+        this.defaultValue = defaultValue;
+    }
+
+    public HookContext(DevCycleUser user, String key, T defaultValue, Variable<T> variable) {
+        this.user = user;
+        this.key = key;
+        this.defaultValue = defaultValue;
+        this.variableDetails = variable;
+    }
+
+    public DevCycleUser getUser() {
+        return user;
+    }
+
+    public String getKey() {
+        return key;
+    }
+
+    public T getDefaultValue() {
+        return defaultValue;
+    }
+
+    public Variable<T> getVariableDetails() { return variableDetails; }
+
+    public HookContext<T> merge(HookContext<T> other) {
+        if (other == null) {
+            return this;
+        }
+        return new HookContext<>(other.getUser(), key, defaultValue, variableDetails);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/com/devcycle/sdk/server/local/api/DevCycleLocalClient.java b/src/main/java/com/devcycle/sdk/server/local/api/DevCycleLocalClient.java
index 6de89d8d..094be70b 100755
--- a/src/main/java/com/devcycle/sdk/server/local/api/DevCycleLocalClient.java
+++ b/src/main/java/com/devcycle/sdk/server/local/api/DevCycleLocalClient.java
@@ -1,6 +1,7 @@
 package com.devcycle.sdk.server.local.api;
 
 import com.devcycle.sdk.server.common.api.IDevCycleClient;
+import com.devcycle.sdk.server.common.exception.BeforeHookError;
 import com.devcycle.sdk.server.common.logging.DevCycleLogger;
 import com.devcycle.sdk.server.common.model.*;
 import com.devcycle.sdk.server.common.model.Variable.TypeEnum;
@@ -18,9 +19,7 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import dev.openfeature.sdk.FeatureProvider;
 
-import java.util.Collections;
-import java.util.Map;
-import java.util.UUID;
+import java.util.*;
 
 public final class DevCycleLocalClient implements IDevCycleClient {
 
@@ -29,6 +28,7 @@ public final class DevCycleLocalClient implements IDevCycleClient {
     private final EnvironmentConfigManager configManager;
     private EventQueueManager eventQueueManager;
     private final String clientUUID;
+    private EvalHooksRunner evalHooksRunner;
 
     public DevCycleLocalClient(String sdkKey) {
         this(sdkKey, DevCycleLocalOptions.builder().build());
@@ -60,6 +60,7 @@ public DevCycleLocalClient(String sdkKey, DevCycleLocalOptions dvcOptions) {
         } catch (Exception e) {
             DevCycleLogger.error("Error creating event queue due to error: " + e.getMessage());
         }
+        this.evalHooksRunner = new EvalHooksRunner();
     }
 
     /**
@@ -155,24 +156,50 @@ public <T> Variable<T> variable(DevCycleUser user, String key, T defaultValue) {
                 .setShouldTrackEvent(true)
                 .build();
 
+        HookContext<T> hookContext = new HookContext<T>(user, key, defaultValue);
+        Variable<T> variable = null;
+        ArrayList<EvalHook<T>> hooks = new ArrayList<EvalHook<T>>(evalHooksRunner.getHooks());
+        ArrayList<EvalHook<T>> reversedHooks = new ArrayList<EvalHook<T>>(evalHooksRunner.getHooks());
+        Collections.reverse(reversedHooks);
+
         try {
             byte[] paramsBuffer = params.toByteArray();
             byte[] variableData = localBucketing.getVariableForUserProtobuf(paramsBuffer);
+            Throwable beforeError = null;
+            try {
+                evalHooksRunner.executeBefore(hooks, hookContext);
+            } catch (Throwable e) {
+                beforeError = e;
+            }
+
 
             if (variableData == null || variableData.length == 0) {
-                return defaultVariable;
+                variable = defaultVariable;
             } else {
                 SDKVariable_PB sdkVariable = SDKVariable_PB.parseFrom(variableData);
                 if (sdkVariable.getType() != pbVariableType) {
                     DevCycleLogger.warning("Variable type mismatch, returning default value");
-                    return defaultVariable;
+                    variable = defaultVariable;
+                } else {
+                    variable = ProtobufUtils.createVariable(sdkVariable, defaultValue);
                 }
-                return ProtobufUtils.createVariable(sdkVariable, defaultValue);
             }
-        } catch (Exception e) {
-            DevCycleLogger.error("Unable to evaluate Variable " + key + " due to error: " + e, e);
+            if (beforeError != null) {
+                throw beforeError;
+            }
+            evalHooksRunner.executeAfter(reversedHooks, hookContext, variable);
+        } catch (Throwable e) {
+            if (!(e instanceof BeforeHookError)) {
+                DevCycleLogger.error("Unable to evaluate Variable " + key + " due to error: " + e, e);
+            }
+            evalHooksRunner.executeError(reversedHooks, hookContext, e);
+        } finally {
+            if (variable == null) {
+                variable = defaultVariable;
+            }
+            evalHooksRunner.executeFinally(reversedHooks, hookContext, Optional.of(variable));
+            return variable;
         }
-        return defaultVariable;
     }
 
 
@@ -247,6 +274,21 @@ public void close() {
         }
     }
 
+    /**
+     * Add an evaluation hook to the client
+     *
+     * @param hook The hook to add
+     */
+    public void addHook(EvalHook hook) {
+        this.evalHooksRunner.addHook(hook);
+    }
+
+    /**
+     * Remove all evaluation hooks from the client
+     */
+    public void clearHooks() {
+        this.evalHooksRunner.clearHooks();
+    }
 
     private static DevCycleProvider openFeatureProvider = null;
 
diff --git a/src/test/java/com/devcycle/sdk/server/cloud/DevCycleCloudClientTest.java b/src/test/java/com/devcycle/sdk/server/cloud/DevCycleCloudClientTest.java
index 466d6fd5..1001ba2e 100755
--- a/src/test/java/com/devcycle/sdk/server/cloud/DevCycleCloudClientTest.java
+++ b/src/test/java/com/devcycle/sdk/server/cloud/DevCycleCloudClientTest.java
@@ -7,17 +7,21 @@
 import com.devcycle.sdk.server.common.exception.DevCycleException;
 import com.devcycle.sdk.server.common.model.*;
 import com.devcycle.sdk.server.helpers.WhiteBox;
+import dev.openfeature.sdk.Hook;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
+import retrofit2.Call;
+import retrofit2.mock.Calls;
 
 import java.math.BigDecimal;
 import java.time.Instant;
 import java.util.Collections;
 import java.util.Map;
+import java.util.Optional;
 import java.util.UUID;
 
 import static org.mockito.Mockito.when;
@@ -57,7 +61,7 @@ public void getFeaturesTest() throws DevCycleException {
                 .country("US")
                 .build();
 
-        when(apiInterface.getFeatures(user, dvcOptions.getEnableEdgeDB())).thenReturn(dvcApiMock.getFeatures(user, dvcOptions.getEnableEdgeDB()));
+        when(apiInterface.getFeatures(user, false)).thenReturn(dvcApiMock.getFeatures(user, false));
 
         Map<String, Feature> features = api.allFeatures(user);
 
@@ -195,6 +199,554 @@ public void postEventsTest() throws DevCycleException {
         assertUserDefaultsCorrect(user);
     }
 
+    @Test
+    public void variable_withEvalHooks_callsHooksInOrder() throws DevCycleException {
+        DevCycleUser user = DevCycleUser.builder()
+                .userId("j_test")
+                .build();
+
+        final boolean[] beforeCalled = {false};
+        final boolean[] afterCalled = {false};
+        final boolean[] finallyCalled = {false};
+
+        api.addHook(new EvalHook<Boolean>() {
+            @Override
+            public Optional<HookContext<Boolean>> before(HookContext<Boolean> ctx) {
+                beforeCalled[0] = true;
+                return Optional.empty();
+            }
+
+            @Override
+            public void after(HookContext<Boolean> ctx, Variable<Boolean> variable) {
+                afterCalled[0] = true;
+                Assert.assertTrue(beforeCalled[0]);
+            }
+
+            @Override
+            public void onFinally(HookContext<Boolean> ctx, Optional<Variable<Boolean>> variable) {
+                finallyCalled[0] = true;
+                Assert.assertTrue(afterCalled[0]);
+            }
+        });
+
+        when(apiInterface.getVariableByKey(user, "test-key", dvcOptions.getEnableEdgeDB())).thenReturn(dvcApiMock.getVariableByKey(user, "test-key", dvcOptions.getEnableEdgeDB()));
+
+        Variable<Boolean> result = api.variable(user, "test-key", true);
+
+        Assert.assertTrue(beforeCalled[0]);
+        Assert.assertTrue(afterCalled[0]);
+        Assert.assertTrue(finallyCalled[0]);
+    }
+
+    @Test
+    public void variable_withEvalHooks_callsErrorHookOnException() {
+        DevCycleUser user = DevCycleUser.builder()
+                .userId("j_test")
+                .build();
+
+        final boolean[] beforeCalled = {false};
+        final boolean[] afterCalled = {false};
+        final boolean[] errorCalled = {false};
+        final boolean[] finallyCalled = {false};
+
+        api.addHook(new EvalHook<Boolean>() {
+            @Override
+            public Optional<HookContext<Boolean>> before(HookContext<Boolean> ctx) {
+                beforeCalled[0] = true;
+                return Optional.of(ctx);
+            }
+
+            @Override
+            public void after(HookContext<Boolean> ctx, Variable<Boolean> variable) {
+                afterCalled[0] = true;
+            }
+
+            @Override
+            public void error(HookContext<Boolean> ctx, Throwable error) {
+                errorCalled[0] = true;
+            }
+
+            @Override
+            public void onFinally(HookContext<Boolean> ctx, Optional<Variable<Boolean>>  variable) {
+                finallyCalled[0] = true;
+            }
+        });
+
+        when(apiInterface.getVariableByKey(user, "test-key", dvcOptions.getEnableEdgeDB())).thenThrow(new RuntimeException("Test error"));
+
+        Variable<Boolean> result = api.variable(user, "test-key", true);
+
+        Assert.assertTrue(beforeCalled[0]);
+        Assert.assertFalse(afterCalled[0]);
+        Assert.assertTrue(errorCalled[0]);
+        Assert.assertTrue(finallyCalled[0]);
+    }
+
+    @Test
+    public void variable_withEvalHooks_returnsVariableWhenBeforeHookThrows() {
+        DevCycleUser user = DevCycleUser.builder()
+                .userId("j_test")
+                .build();
+
+        final boolean[] beforeCalled = {false};
+        final boolean[] afterCalled = {false};
+        final boolean[] errorCalled = {false};
+        final boolean[] finallyCalled = {false};
+
+        api.addHook(new EvalHook<Boolean>() {
+            @Override
+            public Optional<HookContext<Boolean>> before(HookContext<Boolean> ctx) {
+                throw new RuntimeException("Test before hook error");
+            }
+
+            @Override
+            public void after(HookContext<Boolean> ctx, Variable<Boolean> variable) {
+                afterCalled[0] = true;
+            }
+
+            @Override
+            public void error(HookContext<Boolean> ctx, Throwable error) {
+                errorCalled[0] = true;
+            }
+
+            @Override
+            public void onFinally(HookContext<Boolean> ctx, Optional<Variable<Boolean>>  variable) {
+                finallyCalled[0] = true;
+            }
+        });
+
+        Variable<Boolean> expected = Variable.<Boolean>builder()
+                .key("test-true")
+                .value(true)
+                .type(Variable.TypeEnum.BOOLEAN)
+                .isDefaulted(false)
+                .defaultValue(false)
+                .build();
+
+        when(apiInterface.getVariableByKey(user, "test-true", dvcOptions.getEnableEdgeDB())).thenReturn(Calls.response(expected));
+
+        Variable<Boolean> result = api.variable(user, "test-true", false);
+
+        Assert.assertEquals(expected, result);
+        Assert.assertFalse(beforeCalled[0]);
+        Assert.assertFalse(afterCalled[0]);
+        Assert.assertTrue(errorCalled[0]);
+        Assert.assertTrue(finallyCalled[0]);
+    }
+
+    @Test
+    public void variable_withEvalHooks_returnsVariableWhenAfterHookThrows() {
+        DevCycleUser user = DevCycleUser.builder()
+                .userId("j_test")
+                .build();
+
+        final boolean[] beforeCalled = {false};
+        final boolean[] afterCalled = {false};
+        final boolean[] errorCalled = {false};
+        final boolean[] finallyCalled = {false};
+
+        api.addHook(new EvalHook<String>() {
+            @Override
+            public Optional<HookContext<String>> before(HookContext<String> ctx) {
+                beforeCalled[0] = true;
+                return Optional.empty();
+            }
+
+            @Override
+            public void after(HookContext<String> ctx, Variable<String> variable) {
+                afterCalled[0] = true;
+                throw new RuntimeException("Test after hook error");
+            }
+
+            @Override
+            public void error(HookContext<String> ctx, Throwable error) {
+                errorCalled[0] = true;
+            }
+
+            @Override
+            public void onFinally(HookContext<String> ctx, Optional<Variable<String>> variable) {
+                finallyCalled[0] = true;
+            }
+        });
+
+        Variable<String> expected = Variable.<String>builder()
+                .key("test-string")
+                .value("test value")
+                .type(Variable.TypeEnum.STRING)
+                .isDefaulted(false)
+                .defaultValue("default string")
+                .build();
+
+        when(apiInterface.getVariableByKey(user, "test-string", dvcOptions.getEnableEdgeDB())).thenReturn(Calls.response(expected));
+
+        Variable<String> result = api.variable(user, "test-string", "default string");
+
+        Assert.assertNotNull(result);
+        Assert.assertTrue(beforeCalled[0]);
+        Assert.assertTrue(afterCalled[0]);
+        Assert.assertTrue(errorCalled[0]);
+        Assert.assertTrue(finallyCalled[0]);
+    }
+
+    @Test
+    public void variable_withEvalHooks_returnsVariableWhenFinallyHookThrows() {
+        DevCycleUser user = DevCycleUser.builder()
+                .userId("j_test")
+                .build();
+
+        final boolean[] beforeCalled = {false};
+        final boolean[] afterCalled = {false};
+        final boolean[] errorCalled = {false};
+        final boolean[] finallyCalled = {false};
+
+        api.addHook(new EvalHook<String>() {
+            @Override
+            public Optional<HookContext<String>> before(HookContext<String> ctx) {
+                beforeCalled[0] = true;
+                return Optional.empty();
+            }
+
+            @Override
+            public void after(HookContext<String> ctx, Variable<String> variable) {
+                afterCalled[0] = true;
+            }
+
+            @Override
+            public void error(HookContext<String> ctx, Throwable error) {
+                errorCalled[0] = true;
+            }
+
+            @Override
+            public void onFinally(HookContext<String> ctx, Optional<Variable<String>> variable) {
+                finallyCalled[0] = true;
+                throw new RuntimeException("Test finally hook error");
+            }
+        });
+
+        Variable<String> expected = Variable.<String>builder()
+                .key("test-string")
+                .value("test value")
+                .type(Variable.TypeEnum.STRING)
+                .isDefaulted(false)
+                .defaultValue("default string")
+                .build();
+
+        when(apiInterface.getVariableByKey(user, "test-string", dvcOptions.getEnableEdgeDB())).thenReturn(Calls.response(expected));
+
+        Variable<String> result = api.variable(user, "test-string", "default string");
+
+        Assert.assertNotNull(result);
+        Assert.assertTrue(beforeCalled[0]);
+        Assert.assertTrue(afterCalled[0]);
+        Assert.assertFalse(errorCalled[0]); // No error hook should be called for finally errors
+        Assert.assertTrue(finallyCalled[0]);
+    }
+
+    @Test
+    public void variable_withEvalHooks_returnsVariableWhenErrorHookThrows() {
+        DevCycleUser user = DevCycleUser.builder()
+                .userId("j_test")
+                .build();
+
+        final boolean[] beforeCalled = {false};
+        final boolean[] afterCalled = {false};
+        final boolean[] errorCalled = {false};
+        final boolean[] finallyCalled = {false};
+
+        api.addHook(new EvalHook<String>() {
+            @Override
+            public Optional<HookContext<String>> before(HookContext<String> ctx) {
+                throw new RuntimeException("Test before hook error");
+            }
+
+            @Override
+            public void after(HookContext<String> ctx, Variable<String> variable) {
+                afterCalled[0] = true;
+            }
+
+            @Override
+            public void error(HookContext<String> ctx, Throwable error) {
+                errorCalled[0] = true;
+                throw new RuntimeException("Test error hook error");
+            }
+
+            @Override
+            public void onFinally(HookContext<String> ctx, Optional<Variable<String>> variable) {
+                finallyCalled[0] = true;
+            }
+        });
+
+        Variable<String> expected = Variable.<String>builder()
+                .key("test-string")
+                .value("test value")
+                .type(Variable.TypeEnum.STRING)
+                .isDefaulted(false)
+                .defaultValue("default string")
+                .build();
+
+        when(apiInterface.getVariableByKey(user, "test-string", dvcOptions.getEnableEdgeDB())).thenReturn(Calls.response(expected));
+
+        Variable<String> result = api.variable(user, "test-string", "default string");
+
+        Assert.assertNotNull(result);
+        Assert.assertFalse(beforeCalled[0]);
+        Assert.assertFalse(afterCalled[0]);
+        Assert.assertTrue(errorCalled[0]);
+        Assert.assertTrue(finallyCalled[0]);
+    }
+
+    @Test
+    public void variable_withEvalHooks_returnsVariableWhenMultipleHooksThrow() {
+        DevCycleUser user = DevCycleUser.builder()
+                .userId("j_test")
+                .build();
+
+        final boolean[] hook1BeforeCalled = {false};
+        final boolean[] hook1AfterCalled = {false};
+        final boolean[] hook1ErrorCalled = {false};
+        final boolean[] hook1FinallyCalled = {false};
+        final boolean[] hook2BeforeCalled = {false};
+        final boolean[] hook2AfterCalled = {false};
+        final boolean[] hook2ErrorCalled = {false};
+        final boolean[] hook2FinallyCalled = {false};
+
+        // First hook throws in before
+        api.addHook(new EvalHook<String>() {
+            @Override
+            public Optional<HookContext<String>> before(HookContext<String> ctx) {
+                hook1BeforeCalled[0] = true;
+                throw new RuntimeException("Test hook1 before error");
+            }
+
+            @Override
+            public void after(HookContext<String> ctx, Variable<String> variable) {
+                hook1AfterCalled[0] = true;
+            }
+
+            @Override
+            public void error(HookContext<String> ctx, Throwable error) {
+                hook1ErrorCalled[0] = true;
+            }
+
+            @Override
+            public void onFinally(HookContext<String> ctx, Optional<Variable<String>> variable) {
+                hook1FinallyCalled[0] = true;
+            }
+        });
+
+        // Second hook throws in after
+        api.addHook(new EvalHook<String>() {
+            @Override
+            public Optional<HookContext<String>> before(HookContext<String> ctx) {
+                hook2BeforeCalled[0] = true;
+                return Optional.empty();
+            }
+
+            @Override
+            public void after(HookContext<String> ctx, Variable<String> variable) {
+                hook2AfterCalled[0] = true;
+                throw new RuntimeException("Test hook2 after error");
+            }
+
+            @Override
+            public void error(HookContext<String> ctx, Throwable error) {
+                hook2ErrorCalled[0] = true;
+            }
+
+            @Override
+            public void onFinally(HookContext<String> ctx, Optional<Variable<String>> variable) {
+                hook2FinallyCalled[0] = true;
+            }
+        });
+
+        Variable<String> expected = Variable.<String>builder()
+                .key("test-string")
+                .value("test value")
+                .type(Variable.TypeEnum.STRING)
+                .isDefaulted(false)
+                .defaultValue("default string")
+                .build();
+
+        when(apiInterface.getVariableByKey(user, "test-string", dvcOptions.getEnableEdgeDB())).thenReturn(Calls.response(expected));
+
+        Variable<String> result = api.variable(user, "test-string", "default string");
+
+        Assert.assertNotNull(result);
+        Assert.assertFalse(result.getIsDefaulted());
+        // First hook should be called and throw
+        Assert.assertTrue(hook1BeforeCalled[0]);
+        Assert.assertFalse(hook1AfterCalled[0]);
+        Assert.assertTrue(hook1ErrorCalled[0]);
+        Assert.assertTrue(hook1FinallyCalled[0]);
+        // Second hook should not be called due to first hook error
+        Assert.assertFalse(hook2BeforeCalled[0]);
+        Assert.assertFalse(hook2AfterCalled[0]);
+        Assert.assertTrue(hook2ErrorCalled[0]);
+        Assert.assertTrue(hook2FinallyCalled[0]);
+    }
+
+    @Test
+    public void variable_withEvalHooks_returnsVariableWhenHookThrowsCheckedException() {
+        DevCycleUser user = DevCycleUser.builder()
+                .userId("j_test")
+                .build();
+
+        final boolean[] beforeCalled = {false};
+        final boolean[] afterCalled = {false};
+        final boolean[] errorCalled = {false};
+        final boolean[] finallyCalled = {false};
+
+        api.addHook(new EvalHook<String>() {
+            @Override
+            public Optional<HookContext<String>> before(HookContext<String> ctx) {
+                beforeCalled[0] = true;
+                throw new RuntimeException("Test checked exception in before hook");
+            }
+
+            @Override
+            public void after(HookContext<String> ctx, Variable<String> variable) {
+                afterCalled[0] = true;
+            }
+
+            @Override
+            public void error(HookContext<String> ctx, Throwable error) {
+                errorCalled[0] = true;
+                Assert.assertTrue(error instanceof RuntimeException);
+            }
+
+            @Override
+            public void onFinally(HookContext<String> ctx, Optional<Variable<String>> variable) {
+                finallyCalled[0] = true;
+            }
+        });
+
+        Variable<String> expected = Variable.<String>builder()
+                .key("test-string")
+                .value("test value")
+                .type(Variable.TypeEnum.STRING)
+                .isDefaulted(false)
+                .defaultValue("default string")
+                .build();
+
+        when(apiInterface.getVariableByKey(user, "test-string", dvcOptions.getEnableEdgeDB())).thenReturn(Calls.response(expected));
+
+        Variable<String> result = api.variable(user, "test-string", "default string");
+
+        Assert.assertNotNull(result);
+        Assert.assertTrue(beforeCalled[0]);
+        Assert.assertFalse(afterCalled[0]);
+        Assert.assertTrue(errorCalled[0]);
+        Assert.assertTrue(finallyCalled[0]);
+    }
+
+    @Test
+    public void variable_withEvalHooks_returnsVariableWhenHookThrowsInFinallyAfterError() {
+        DevCycleUser user = DevCycleUser.builder()
+                .userId("j_test")
+                .build();
+
+        final boolean[] beforeCalled = {false};
+        final boolean[] afterCalled = {false};
+        final boolean[] errorCalled = {false};
+        final boolean[] finallyCalled = {false};
+
+        api.addHook(new EvalHook<String>() {
+            @Override
+            public Optional<HookContext<String>> before(HookContext<String> ctx) {
+                beforeCalled[0] = true;
+                throw new RuntimeException("Test before hook error");
+            }
+
+            @Override
+            public void after(HookContext<String> ctx, Variable<String> variable) {
+                afterCalled[0] = true;
+            }
+
+            @Override
+            public void error(HookContext<String> ctx, Throwable error) {
+                errorCalled[0] = true;
+            }
+
+            @Override
+            public void onFinally(HookContext<String> ctx, Optional<Variable<String>> variable) {
+                finallyCalled[0] = true;
+                throw new RuntimeException("Test finally hook error after previous error");
+            }
+        });
+
+        Variable<String> expected = Variable.<String>builder()
+                .key("test-string")
+                .value("test value")
+                .type(Variable.TypeEnum.STRING)
+                .isDefaulted(false)
+                .defaultValue("default string")
+                .build();
+
+        when(apiInterface.getVariableByKey(user, "test-string", dvcOptions.getEnableEdgeDB())).thenReturn(Calls.response(expected));
+
+        Variable<String> result = api.variable(user, "test-string", "default string");
+
+        Assert.assertNotNull(result);
+        Assert.assertTrue(beforeCalled[0]);
+        Assert.assertFalse(afterCalled[0]);
+        Assert.assertTrue(errorCalled[0]);
+        Assert.assertTrue(finallyCalled[0]);
+    }
+
+    @Test
+    public void variable_withEvalHooks_returnsVariableWhenHookThrowsInErrorAfterFinally() {
+        DevCycleUser user = DevCycleUser.builder()
+                .userId("j_test")
+                .build();
+
+        final boolean[] beforeCalled = {false};
+        final boolean[] afterCalled = {false};
+        final boolean[] errorCalled = {false};
+        final boolean[] finallyCalled = {false};
+
+        api.addHook(new EvalHook<String>() {
+            @Override
+            public Optional<HookContext<String>> before(HookContext<String> ctx) {
+                beforeCalled[0] = true;
+                throw new RuntimeException("Test before hook error");
+            }
+
+            @Override
+            public void after(HookContext<String> ctx, Variable<String> variable) {
+                afterCalled[0] = true;
+            }
+
+            @Override
+            public void error(HookContext<String> ctx, Throwable error) {
+                errorCalled[0] = true;
+                throw new RuntimeException("Test error hook error after before error");
+            }
+
+            @Override
+            public void onFinally(HookContext<String> ctx, Optional<Variable<String>> variable) {
+                finallyCalled[0] = true;
+            }
+        });
+
+        Variable<String> expected = Variable.<String>builder()
+                .key("test-string")
+                .value("test value")
+                .type(Variable.TypeEnum.STRING)
+                .isDefaulted(false)
+                .defaultValue("default string")
+                .build();
+
+        when(apiInterface.getVariableByKey(user, "test-string", dvcOptions.getEnableEdgeDB())).thenReturn(Calls.response(expected));
+
+        Variable<String> result = api.variable(user, "test-string", "default string");
+
+        Assert.assertNotNull(result);
+        Assert.assertTrue(beforeCalled[0]);
+        Assert.assertFalse(afterCalled[0]);
+        Assert.assertTrue(errorCalled[0]);
+        Assert.assertTrue(finallyCalled[0]);
+    }
+
     private void assertUserDefaultsCorrect(DevCycleUser user) {
         Assert.assertEquals("Java", user.getPlatform());
         Assert.assertEquals(PlatformData.SdkTypeEnum.SERVER, user.getSdkType());
diff --git a/src/test/java/com/devcycle/sdk/server/cloud/EvalHooksRunnerTest.java b/src/test/java/com/devcycle/sdk/server/cloud/EvalHooksRunnerTest.java
new file mode 100644
index 00000000..0917d1f3
--- /dev/null
+++ b/src/test/java/com/devcycle/sdk/server/cloud/EvalHooksRunnerTest.java
@@ -0,0 +1,151 @@
+package com.devcycle.sdk.server.cloud;
+
+import com.devcycle.sdk.server.common.exception.AfterHookError;
+import com.devcycle.sdk.server.common.exception.BeforeHookError;
+import com.devcycle.sdk.server.common.model.*;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Optional;
+
+public class EvalHooksRunnerTest {
+
+    private EvalHooksRunner hookRunner;
+    private DevCycleUser testUser;
+    private Variable<Boolean> testVariable;
+
+    @Before
+    public void setup() {
+        hookRunner = new EvalHooksRunner();
+        testUser = DevCycleUser.builder().userId("test-user").build();
+        testVariable = Variable.<Boolean>builder()
+                .key("test-var")
+                .value(true)
+                .type(Variable.TypeEnum.BOOLEAN)
+                .build();
+    }
+
+    @Test
+    public void testBeforeHook() {
+        HookContext<Boolean> context = new HookContext<>(testUser, "test-key", false);
+        
+        ArrayList<EvalHook<Boolean>> hooks = new ArrayList<>();
+        hooks.add(new EvalHook<Boolean>() {
+            @Override
+            public Optional<HookContext<Boolean>> before(HookContext<Boolean> ctx) {
+                DevCycleUser modifiedUser = DevCycleUser.builder()
+                    .userId("modified-user")
+                    .build();
+                return Optional.of(new HookContext<>(modifiedUser, ctx.getKey(), ctx.getDefaultValue()));
+            }
+        });
+
+        HookContext<Boolean> result = hookRunner.executeBefore(hooks, context);
+        Assert.assertEquals("modified-user", result.getUser().getUserId());
+    }
+
+    @Test(expected = BeforeHookError.class)
+    public void testBeforeHookError() {
+        HookContext<Boolean> context = new HookContext<>(testUser, "test-key", false);
+        
+        ArrayList<EvalHook<Boolean>> hooks = new ArrayList<>();
+        hooks.add(new EvalHook<Boolean>() {
+            @Override
+            public Optional<HookContext<Boolean>> before(HookContext<Boolean> ctx) {
+                throw new RuntimeException("Test error");
+            }
+        });
+
+        hookRunner.executeBefore(hooks, context);
+    }
+
+    @Test
+    public void testAfterHook() {
+        final boolean[] hookCalled = {false};
+        HookContext<Boolean> context = new HookContext<>(testUser, "test-key", false);
+
+        ArrayList<EvalHook<Boolean>> hooks = new ArrayList<>();
+        hooks.add(new EvalHook<Boolean>() {
+            @Override
+            public void after(HookContext<Boolean> ctx, Variable<Boolean> variable) {
+                hookCalled[0] = true;
+                Assert.assertEquals("test-var", variable.getKey());
+            }
+        });
+
+        hookRunner.executeAfter(hooks, context, testVariable);
+        Assert.assertTrue(hookCalled[0]);
+    }
+
+    @Test(expected = AfterHookError.class)
+    public void testAfterHookError() {
+        HookContext<Boolean> context = new HookContext<>(testUser, "test-key", false);
+        
+        ArrayList<EvalHook<Boolean>> hooks = new ArrayList<>();
+        hooks.add(new EvalHook<Boolean>() {
+            @Override
+            public void after(HookContext<Boolean> ctx, Variable<Boolean> variable) {
+                throw new RuntimeException("Test error");
+            }
+        });
+
+        hookRunner.executeAfter(hooks, context, testVariable);
+    }
+
+    @Test
+    public void testErrorHook() {
+        final boolean[] hookCalled = {false};
+        HookContext<Boolean> context = new HookContext<>(testUser, "test-key", false);
+        Exception testError = new Exception("Test error");
+
+        ArrayList<EvalHook<Boolean>> hooks = new ArrayList<>();
+        hooks.add(new EvalHook<Boolean>() {
+            @Override
+            public void error(HookContext<Boolean> ctx, Throwable error) {
+                hookCalled[0] = true;
+                Assert.assertEquals("Test error", error.getMessage());
+            }
+        });
+
+        hookRunner.executeError(hooks, context, testError);
+        Assert.assertTrue(hookCalled[0]);
+    }
+
+    @Test
+    public void testFinallyHook() {
+        final boolean[] hookCalled = {false};
+        HookContext<Boolean> context = new HookContext<>(testUser, "test-key", false);
+
+        ArrayList<EvalHook<Boolean>> hooks = new ArrayList<>();
+        hooks.add(new EvalHook<Boolean>() {
+            @Override
+            public void onFinally(HookContext<Boolean> ctx, Optional<Variable<Boolean>>  variable) {
+                hookCalled[0] = true;
+            }
+        });
+
+        hookRunner.executeFinally(hooks, context, Optional.ofNullable(testVariable));
+        Assert.assertTrue(hookCalled[0]);
+    }
+
+    @Test
+    public void testClearHooks() {
+        final boolean[] hookCalled = {false};
+        HookContext<Boolean> context = new HookContext<>(testUser, "test-key", false);
+
+        ArrayList<EvalHook<Boolean>> hooks = new ArrayList<>();
+        hooks.add(new EvalHook<Boolean>() {
+            @Override
+            public void after(HookContext<Boolean> ctx, Variable<Boolean> variable) {
+                hookCalled[0] = true;
+            }
+        });
+
+        // Test that empty hooks array doesn't call any hooks
+        ArrayList<EvalHook<Boolean>> emptyHooks = new ArrayList<>();
+        hookRunner.executeAfter(emptyHooks, context, testVariable);
+        Assert.assertFalse(hookCalled[0]);
+    }
+}
diff --git a/src/test/java/com/devcycle/sdk/server/local/DevCycleLocalClientTest.java b/src/test/java/com/devcycle/sdk/server/local/DevCycleLocalClientTest.java
index fce62bb5..0cbc27c6 100644
--- a/src/test/java/com/devcycle/sdk/server/local/DevCycleLocalClientTest.java
+++ b/src/test/java/com/devcycle/sdk/server/local/DevCycleLocalClientTest.java
@@ -1,6 +1,7 @@
 package com.devcycle.sdk.server.local;
 
 import com.devcycle.sdk.server.common.api.IRestOptions;
+import com.devcycle.sdk.server.common.exception.DevCycleException;
 import com.devcycle.sdk.server.common.logging.IDevCycleLogger;
 import com.devcycle.sdk.server.common.model.*;
 import com.devcycle.sdk.server.helpers.LocalConfigServer;
@@ -11,6 +12,7 @@
 import org.junit.Assert;
 import org.junit.BeforeClass;
 import org.junit.Test;
+import org.junit.After;
 import org.junit.runner.RunWith;
 import org.mockito.junit.MockitoJUnitRunner;
 
@@ -20,6 +22,7 @@
 import java.math.BigDecimal;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Optional;
 import java.util.UUID;
 
 @RunWith(MockitoJUnitRunner.class)
@@ -365,6 +368,487 @@ public void allFeaturesWithSpecialCharsTest() {
         Assert.assertEquals(features.size(), 1);
     }
 
+    @Test
+    public void variable_withEvalHooks_callsHooksInOrder() throws DevCycleException {
+        DevCycleUser user = DevCycleUser.builder()
+                .userId("j_test")
+                .build();
+
+        final boolean[] beforeCalled = {false};
+        final boolean[] afterCalled = {false};
+        final boolean[] finallyCalled = {false};
+
+        client.addHook(new EvalHook<String>() {
+            @Override
+            public Optional<HookContext<String>> before(HookContext<String> ctx) {
+                beforeCalled[0] = true;
+                return Optional.empty();
+            }
+
+            @Override
+            public void after(HookContext<String> ctx, Variable<String> variable) {
+                afterCalled[0] = true;
+                Assert.assertTrue(beforeCalled[0]);
+            }
+
+            @Override
+            public void onFinally(HookContext<String> ctx, Optional<Variable<String>> variable) {
+                finallyCalled[0] = true;
+                Assert.assertTrue(afterCalled[0]);
+            }
+        });
+
+        Variable<String> result = client.variable(user, "string-var", "default string");
+
+        Assert.assertTrue(beforeCalled[0]);
+        Assert.assertTrue(afterCalled[0]);
+        Assert.assertTrue(finallyCalled[0]);
+    }
+
+    @Test
+    public void variable_withEvalHooks_returnsVariableWhenBeforeHookThrows() {
+        DevCycleUser user = DevCycleUser.builder()
+                .userId("j_test")
+                .build();
+
+        final boolean[] beforeCalled = {false};
+        final boolean[] afterCalled = {false};
+        final boolean[] errorCalled = {false};
+        final boolean[] finallyCalled = {false};
+
+        client.addHook(new EvalHook<String>() {
+            @Override
+            public Optional<HookContext<String>> before(HookContext<String> ctx) {
+                throw new RuntimeException("Test before hook error");
+            }
+
+            @Override
+            public void after(HookContext<String> ctx, Variable<String> variable) {
+                afterCalled[0] = true;
+            }
+
+            @Override
+            public void error(HookContext<String> ctx, Throwable error) {
+                errorCalled[0] = true;
+            }
+
+            @Override
+            public void onFinally(HookContext<String> ctx, Optional<Variable<String>> variable) {
+                finallyCalled[0] = true;
+            }
+        });
+
+        Variable<String> result = client.variable(user, "string-var", "default string");
+
+        Assert.assertNotNull(result);
+        Assert.assertFalse(beforeCalled[0]);
+        Assert.assertFalse(afterCalled[0]);
+        Assert.assertTrue(errorCalled[0]);
+        Assert.assertTrue(finallyCalled[0]);
+    }
+
+    @Test
+    public void variable_withEvalHooks_returnsVariableWhenAfterHookThrows() {
+        DevCycleUser user = DevCycleUser.builder()
+                .userId("j_test")
+                .build();
+
+        final boolean[] beforeCalled = {false};
+        final boolean[] afterCalled = {false};
+        final boolean[] errorCalled = {false};
+        final boolean[] finallyCalled = {false};
+
+        client.addHook(new EvalHook<String>() {
+            @Override
+            public Optional<HookContext<String>> before(HookContext<String> ctx) {
+                beforeCalled[0] = true;
+                return Optional.empty();
+            }
+
+            @Override
+            public void after(HookContext<String> ctx, Variable<String> variable) {
+                afterCalled[0] = true;
+                throw new RuntimeException("Test after hook error");
+            }
+
+            @Override
+            public void error(HookContext<String> ctx, Throwable error) {
+                errorCalled[0] = true;
+            }
+
+            @Override
+            public void onFinally(HookContext<String> ctx, Optional<Variable<String>> variable) {
+                finallyCalled[0] = true;
+            }
+        });
+
+        Variable<String> result = client.variable(user, "string-var", "default string");
+
+        Assert.assertNotNull(result);
+        Assert.assertTrue(beforeCalled[0]);
+        Assert.assertTrue(afterCalled[0]);
+        Assert.assertTrue(errorCalled[0]);
+        Assert.assertTrue(finallyCalled[0]);
+    }
+
+    @Test
+    public void variable_withEvalHooks_returnsVariableWhenFinallyHookThrows() {
+        DevCycleUser user = DevCycleUser.builder()
+                .userId("j_test")
+                .build();
+
+        final boolean[] beforeCalled = {false};
+        final boolean[] afterCalled = {false};
+        final boolean[] errorCalled = {false};
+        final boolean[] finallyCalled = {false};
+
+        client.addHook(new EvalHook<String>() {
+            @Override
+            public Optional<HookContext<String>> before(HookContext<String> ctx) {
+                beforeCalled[0] = true;
+                return Optional.empty();
+            }
+
+            @Override
+            public void after(HookContext<String> ctx, Variable<String> variable) {
+                afterCalled[0] = true;
+            }
+
+            @Override
+            public void error(HookContext<String> ctx, Throwable error) {
+                errorCalled[0] = true;
+            }
+
+            @Override
+            public void onFinally(HookContext<String> ctx, Optional<Variable<String>> variable) {
+                finallyCalled[0] = true;
+                throw new RuntimeException("Test finally hook error");
+            }
+        });
+
+        Variable<String> result = client.variable(user, "string-var", "default string");
+
+        Assert.assertNotNull(result);
+        Assert.assertTrue(beforeCalled[0]);
+        Assert.assertTrue(afterCalled[0]);
+        Assert.assertFalse(errorCalled[0]); // No error hook should be called for finally errors
+        Assert.assertTrue(finallyCalled[0]);
+    }
+
+    @Test
+    public void variable_withEvalHooks_returnsVariableWhenErrorHookThrows() {
+        DevCycleUser user = DevCycleUser.builder()
+                .userId("j_test")
+                .build();
+
+        final boolean[] beforeCalled = {false};
+        final boolean[] afterCalled = {false};
+        final boolean[] errorCalled = {false};
+        final boolean[] finallyCalled = {false};
+
+        client.addHook(new EvalHook<String>() {
+            @Override
+            public Optional<HookContext<String>> before(HookContext<String> ctx) {
+                throw new RuntimeException("Test before hook error");
+            }
+
+            @Override
+            public void after(HookContext<String> ctx, Variable<String> variable) {
+                afterCalled[0] = true;
+            }
+
+            @Override
+            public void error(HookContext<String> ctx, Throwable error) {
+                errorCalled[0] = true;
+                throw new RuntimeException("Test error hook error");
+            }
+
+            @Override
+            public void onFinally(HookContext<String> ctx, Optional<Variable<String>> variable) {
+                finallyCalled[0] = true;
+            }
+        });
+
+        Variable<String> result = client.variable(user, "string-var", "default string");
+
+        Assert.assertNotNull(result);
+        Assert.assertFalse(beforeCalled[0]);
+        Assert.assertFalse(afterCalled[0]);
+        Assert.assertTrue(errorCalled[0]);
+        Assert.assertTrue(finallyCalled[0]);
+    }
+
+    @Test
+    public void variable_withEvalHooks_returnsVariableWhenMultipleHooksThrow() {
+        DevCycleUser user = DevCycleUser.builder()
+                .userId("j_test")
+                .email("giveMeVariationOn@email.com")
+                .build();
+
+        final boolean[] hook1BeforeCalled = {false};
+        final boolean[] hook1AfterCalled = {false};
+        final boolean[] hook1ErrorCalled = {false};
+        final boolean[] hook1FinallyCalled = {false};
+        final boolean[] hook2BeforeCalled = {false};
+        final boolean[] hook2AfterCalled = {false};
+        final boolean[] hook2ErrorCalled = {false};
+        final boolean[] hook2FinallyCalled = {false};
+
+        // First hook throws in before
+        client.addHook(new EvalHook<String>() {
+            @Override
+            public Optional<HookContext<String>> before(HookContext<String> ctx) {
+                hook1BeforeCalled[0] = true;
+                throw new RuntimeException("Test hook1 before error");
+            }
+
+            @Override
+            public void after(HookContext<String> ctx, Variable<String> variable) {
+                hook1AfterCalled[0] = true;
+            }
+
+            @Override
+            public void error(HookContext<String> ctx, Throwable error) {
+                hook1ErrorCalled[0] = true;
+            }
+
+            @Override
+            public void onFinally(HookContext<String> ctx, Optional<Variable<String>> variable) {
+                hook1FinallyCalled[0] = true;
+            }
+        });
+
+        // Second hook throws in after
+        client.addHook(new EvalHook<String>() {
+            @Override
+            public Optional<HookContext<String>> before(HookContext<String> ctx) {
+                hook2BeforeCalled[0] = true;
+                return Optional.empty();
+            }
+
+            @Override
+            public void after(HookContext<String> ctx, Variable<String> variable) {
+                hook2AfterCalled[0] = true;
+                throw new RuntimeException("Test hook2 after error");
+            }
+
+            @Override
+            public void error(HookContext<String> ctx, Throwable error) {
+                hook2ErrorCalled[0] = true;
+            }
+
+            @Override
+            public void onFinally(HookContext<String> ctx, Optional<Variable<String>> variable) {
+                hook2FinallyCalled[0] = true;
+            }
+        });
+
+        Variable<String> expected = Variable.<String>builder()
+                .key("string-var")
+                .value("variationOn")
+                .type(Variable.TypeEnum.STRING)
+                .isDefaulted(false)
+                .defaultValue("default string")
+                .build();
+
+        Variable<String> result = client.variable(user, "string-var", "default string");
+
+        Assert.assertEquals(expected, result);
+        // First hook should be called and throw
+        Assert.assertTrue(hook1BeforeCalled[0]);
+        Assert.assertFalse(hook1AfterCalled[0]);
+        Assert.assertTrue(hook1ErrorCalled[0]);
+        Assert.assertTrue(hook1FinallyCalled[0]);
+        // Second hook should not be called due to first hook error
+        Assert.assertFalse(hook2BeforeCalled[0]);
+        Assert.assertFalse(hook2AfterCalled[0]);
+        Assert.assertTrue(hook2ErrorCalled[0]);
+        Assert.assertTrue(hook2FinallyCalled[0]);
+    }
+
+    @Test
+    public void variable_withEvalHooks_returnsVariableWhenHookThrowsCheckedException() {
+        DevCycleUser user = DevCycleUser.builder()
+                .userId("j_test")
+                .build();
+
+        final boolean[] beforeCalled = {false};
+        final boolean[] afterCalled = {false};
+        final boolean[] errorCalled = {false};
+        final boolean[] finallyCalled = {false};
+
+        client.addHook(new EvalHook<String>() {
+            @Override
+            public Optional<HookContext<String>> before(HookContext<String> ctx) {
+                beforeCalled[0] = true;
+                throw new RuntimeException("Test checked exception in before hook");
+            }
+
+            @Override
+            public void after(HookContext<String> ctx, Variable<String> variable) {
+                afterCalled[0] = true;
+            }
+
+            @Override
+            public void error(HookContext<String> ctx, Throwable error) {
+                errorCalled[0] = true;
+                Assert.assertTrue(error instanceof RuntimeException);
+                Assert.assertEquals("Test checked exception in before hook", error.getMessage());
+            }
+
+            @Override
+            public void onFinally(HookContext<String> ctx, Optional<Variable<String>> variable) {
+                finallyCalled[0] = true;
+            }
+        });
+
+        Variable<String> result = client.variable(user, "string-var", "default string");
+
+        Assert.assertNotNull(result);
+        Assert.assertTrue(beforeCalled[0]);
+        Assert.assertFalse(afterCalled[0]);
+        Assert.assertTrue(errorCalled[0]);
+        Assert.assertTrue(finallyCalled[0]);
+    }
+
+    @Test
+    public void variable_withEvalHooks_returnsVariableWhenHookThrowsNullPointerException() {
+        DevCycleUser user = DevCycleUser.builder()
+                .userId("j_test")
+                .build();
+
+        final boolean[] beforeCalled = {false};
+        final boolean[] afterCalled = {false};
+        final boolean[] errorCalled = {false};
+        final boolean[] finallyCalled = {false};
+
+        client.addHook(new EvalHook<String>() {
+            @Override
+            public Optional<HookContext<String>> before(HookContext<String> ctx) {
+                beforeCalled[0] = true;
+                throw new NullPointerException("Test NPE in before hook");
+            }
+
+            @Override
+            public void after(HookContext<String> ctx, Variable<String> variable) {
+                afterCalled[0] = true;
+            }
+
+            @Override
+            public void error(HookContext<String> ctx, Throwable error) {
+                errorCalled[0] = true;
+                Assert.assertTrue(error instanceof NullPointerException);
+                Assert.assertEquals("Test NPE in before hook", error.getMessage());
+            }
+
+            @Override
+            public void onFinally(HookContext<String> ctx, Optional<Variable<String>> variable) {
+                finallyCalled[0] = true;
+            }
+        });
+
+        Variable<String> result = client.variable(user, "string-var", "default string");
+
+        Assert.assertNotNull(result);
+        Assert.assertTrue(beforeCalled[0]);
+        Assert.assertFalse(afterCalled[0]);
+        Assert.assertTrue(errorCalled[0]);
+        Assert.assertTrue(finallyCalled[0]);
+    }
+
+    @Test
+    public void variable_withEvalHooks_returnsVariableWhenHookThrowsInFinallyAfterError() {
+        DevCycleUser user = DevCycleUser.builder()
+                .userId("j_test")
+                .build();
+
+        final boolean[] beforeCalled = {false};
+        final boolean[] afterCalled = {false};
+        final boolean[] errorCalled = {false};
+        final boolean[] finallyCalled = {false};
+
+        client.addHook(new EvalHook<String>() {
+            @Override
+            public Optional<HookContext<String>> before(HookContext<String> ctx) {
+                beforeCalled[0] = true;
+                throw new RuntimeException("Test before hook error");
+            }
+
+            @Override
+            public void after(HookContext<String> ctx, Variable<String> variable) {
+                afterCalled[0] = true;
+            }
+
+            @Override
+            public void error(HookContext<String> ctx, Throwable error) {
+                errorCalled[0] = true;
+            }
+
+            @Override
+            public void onFinally(HookContext<String> ctx, Optional<Variable<String>> variable) {
+                finallyCalled[0] = true;
+                throw new RuntimeException("Test finally hook error after previous error");
+            }
+        });
+
+        Variable<String> result = client.variable(user, "string-var", "default string");
+
+        Assert.assertNotNull(result);
+        Assert.assertTrue(beforeCalled[0]);
+        Assert.assertFalse(afterCalled[0]);
+        Assert.assertTrue(errorCalled[0]);
+        Assert.assertTrue(finallyCalled[0]);
+    }
+
+    @Test
+    public void variable_withEvalHooks_returnsVariableWhenHookThrowsInErrorAfterFinally() {
+        DevCycleUser user = DevCycleUser.builder()
+                .userId("j_test")
+                .build();
+
+        final boolean[] beforeCalled = {false};
+        final boolean[] afterCalled = {false};
+        final boolean[] errorCalled = {false};
+        final boolean[] finallyCalled = {false};
+
+        client.addHook(new EvalHook<String>() {
+            @Override
+            public Optional<HookContext<String>> before(HookContext<String> ctx) {
+                beforeCalled[0] = true;
+                throw new RuntimeException("Test before hook error");
+            }
+
+            @Override
+            public void after(HookContext<String> ctx, Variable<String> variable) {
+                afterCalled[0] = true;
+            }
+
+            @Override
+            public void error(HookContext<String> ctx, Throwable error) {
+                errorCalled[0] = true;
+                throw new RuntimeException("Test error hook error after before error");
+            }
+
+            @Override
+            public void onFinally(HookContext<String> ctx, Optional<Variable<String>> variable) {
+                finallyCalled[0] = true;
+            }
+        });
+
+        Variable<String> result = client.variable(user, "string-var", "default string");
+
+        Assert.assertNotNull(result);
+        Assert.assertTrue(beforeCalled[0]);
+        Assert.assertFalse(afterCalled[0]);
+        Assert.assertTrue(errorCalled[0]);
+        Assert.assertTrue(finallyCalled[0]);
+    }
+
+    @After
+    public void clearHooks() {
+        client.clearHooks();
+    }
+
     private DevCycleUser getUser() {
         return DevCycleUser.builder()
                 .userId("j_test")