diff --git a/src/ui/src/builder/BuilderLogWorkflowExecution.vue b/src/ui/src/builder/BuilderLogWorkflowExecution.vue
index 62171723c..133fa97a2 100644
--- a/src/ui/src/builder/BuilderLogWorkflowExecution.vue
+++ b/src/ui/src/builder/BuilderLogWorkflowExecution.vue
@@ -119,12 +119,18 @@
 				<div class="time">
 					{{ formatExecutionTime(item.executionTimeInSeconds) }}
 				</div>
+				<div
+					v-if="item.message"
+					v-dompurify-html="marked.parse(item.message)"
+					class="message markdown"
+				></div>
 			</div>
 		</div>
 	</div>
 </template>
 
 <script setup lang="ts">
+import { marked } from "marked";
 import injectionKeys from "@/injectionKeys";
 import { WorkflowExecutionLog } from "./builderManager";
 import { computed, inject, nextTick, ref } from "vue";
@@ -230,7 +236,7 @@ function formatExecutionTime(timeInSeconds: number): string {
 	grid-row: 1 / 3;
 	display: grid;
 	grid-template-columns: 1fr 1fr 1fr 80px;
-	grid-template-rows: 1fr;
+	grid-template-rows: 1fr auto;
 	align-items: center;
 	padding: 8px;
 	border-radius: 6px;
@@ -281,6 +287,12 @@ function formatExecutionTime(timeInSeconds: number): string {
 	grid-row: 1 / 2;
 }
 
+.item .message {
+	grid-column: 1 / 5;
+	grid-row: 2 / 3;
+	margin-top: 8px;
+}
+
 .detailsModalContent {
 	display: flex;
 	flex-direction: column;
@@ -299,4 +311,11 @@ function formatExecutionTime(timeInSeconds: number): string {
 	margin-top: 8px;
 	font-size: 14px;
 }
+
+.markdown :deep(code) {
+	font-family: monospace;
+	font-size: 13px;
+	background-color: rgba(0, 0, 0, 0.05);
+	padding: 2px;
+}
 </style>
diff --git a/src/ui/src/builder/builderManager.ts b/src/ui/src/builder/builderManager.ts
index b3e86336a..e6c88cd2d 100644
--- a/src/ui/src/builder/builderManager.ts
+++ b/src/ui/src/builder/builderManager.ts
@@ -18,6 +18,7 @@ export type WorkflowExecutionLog = {
 	summary: {
 		componentId: Component["id"];
 		outcome: string;
+		message?: string;
 		executionTimeInSeconds: number;
 		// eslint-disable-next-line @typescript-eslint/no-explicit-any
 		result: any;
diff --git a/src/writer/blocks/addtostatelist.py b/src/writer/blocks/addtostatelist.py
index 6b9e1121b..26be22f78 100644
--- a/src/writer/blocks/addtostatelist.py
+++ b/src/writer/blocks/addtostatelist.py
@@ -1,6 +1,6 @@
 from writer.abstract import register_abstract_template
 from writer.blocks.base_block import WorkflowBlock
-from writer.ss_types import AbstractTemplate
+from writer.ss_types import AbstractTemplate, WriterConfigurationError
 
 
 class AddToStateList(WorkflowBlock):
@@ -45,12 +45,12 @@ def run(self):
             element_expr = self._get_field("element")
             value = self._get_field("value")
 
-            element = self.runner.evaluator.evaluate_expression(element_expr, self.instance_path, self.execution_environment)
+            element = self.evaluator.evaluate_expression(element_expr, self.instance_path, self.execution_environment)
 
             if not element:
                 element = []
             elif not isinstance(element, list):
-                element = [element]
+                raise WriterConfigurationError(f'The state element must be a list. A value of type "{type(element)}" was found.')
 
             element.append(value)
             self._set_state(element_expr, element)
diff --git a/src/writer/blocks/base_block.py b/src/writer/blocks/base_block.py
index d5f201779..6d064a912 100644
--- a/src/writer/blocks/base_block.py
+++ b/src/writer/blocks/base_block.py
@@ -1,6 +1,7 @@
 from typing import TYPE_CHECKING, Any, Dict, Type
 
 import writer.evaluator
+from writer.ss_types import WriterConfigurationError
 
 if TYPE_CHECKING:
     from writer.core_ui import Component
@@ -16,24 +17,38 @@ class WorkflowBlock:
     def register(cls, type: str):
         block_map[type] = cls
 
-    def __init__(self, component: "Component", runner: "WorkflowRunner", execution_environment: Dict):
+    def __init__(self, component_id: str, runner: "WorkflowRunner", execution_environment: Dict):
         self.outcome = None
-        self.component = component
+        self.message = None
+        self.component_id = component_id
         self.runner = runner
         self.execution_time_in_seconds = -1.0
         self.execution_environment = execution_environment
         self.result = None
         self.return_value = None
-        self.instance_path: InstancePath = [{"componentId": self.component.id, "instanceNumber": 0}]
+        self.instance_path: InstancePath = [{"componentId": component_id, "instanceNumber": 0}]
         self.evaluator = writer.evaluator.Evaluator(runner.session.session_state, runner.session.session_component_tree)
 
-    def _get_field(self, field_key: str, as_json=False, default_field_value=None):
+    def _handle_missing_field(self, field_key):
+        component_tree = self.runner.session.session_component_tree
+        component = component_tree.get_component(self.component_id)
+        field_content = component.content.get(field_key)
+        if field_content:
+            raise WriterConfigurationError(f'The field `{field_key}` is required. The expression specified, `{field_content}`, resulted in an empty value.')
+        else:
+            raise WriterConfigurationError(f'The field `{field_key}` is required. It was left empty.')
+
+    def _get_field(self, field_key: str, as_json=False, default_field_value=None, required=False):
         if default_field_value is None:
             if as_json:
                 default_field_value = "{}"
             else:
                 default_field_value = ""
         value = self.evaluator.evaluate_field(self.instance_path, field_key, as_json, default_field_value, self.execution_environment)
+
+        if required and (value is None or value == "" or value == {}):
+            self._handle_missing_field(field_key)
+            
         return value
 
     def _set_state(self, expr: str, value: Any):
diff --git a/src/writer/blocks/calleventhandler.py b/src/writer/blocks/calleventhandler.py
index e01458e01..31d08d9dc 100644
--- a/src/writer/blocks/calleventhandler.py
+++ b/src/writer/blocks/calleventhandler.py
@@ -56,7 +56,7 @@ def run(self):
             callable_handler = handler_registry.find_handler_callable(handler_name)
 
             args = {
-                "state": self.session.session_state,
+                "state": self.runner.session.session_state,
                 "context": self.execution_environment,
                 "session": writer.core._event_handler_session_info(),
             } | additional_args
diff --git a/src/writer/blocks/httprequest.py b/src/writer/blocks/httprequest.py
index 48efc5364..6d403734c 100644
--- a/src/writer/blocks/httprequest.py
+++ b/src/writer/blocks/httprequest.py
@@ -68,7 +68,7 @@ def run(self):
         import json
 
         try:
-            method = self._get_field("method", False, "get")
+            method = self._get_field("method", False, "GET")
             url = self._get_field("url")
             headers = self._get_field("headers", True)
             body = self._get_field("body")
@@ -87,9 +87,10 @@ def run(self):
             else:
                 self.outcome = "responseError"
                 raise RuntimeError("HTTP response with code " + str(req.status_code))
-        except json.JSONDecodeError:
-            self.result = "JSON decode error. The response contains invalid JSON."
+        except json.JSONDecodeError as e:
             self.outcome = "responseError"
+            raise e
         except BaseException as e:
-            self.outcome = "connectionError"
+            if not self.outcome:
+                self.outcome = "connectionError"
             raise e
\ No newline at end of file
diff --git a/src/writer/blocks/logmessage.py b/src/writer/blocks/logmessage.py
index 6b1be0c39..c2013172c 100644
--- a/src/writer/blocks/logmessage.py
+++ b/src/writer/blocks/logmessage.py
@@ -48,16 +48,9 @@ def register(cls, type: str):
     def run(self):
         try:
             type = self._get_field("type", False, "info")
-            message = self._get_field("message")
+            message = self._get_field("message", required=True)
 
-            if message is None:
-                self.result = "Message cannot be empty."
-                self.outcome = "error"
-                return
-
-            self.runner.state.add_log_entry(type, "Workflows message", message)
-            import time
-            self.runner.state.add_log_entry("error", "Workflows message", f"gato {time.time()}")
+            self.runner.session.session_state.add_log_entry(type, "Workflows message", message)
             self.result = None
             self.outcome = "success"
         except BaseException as e:
diff --git a/src/writer/blocks/returnvalue.py b/src/writer/blocks/returnvalue.py
index e43266f08..b54cb2bf1 100644
--- a/src/writer/blocks/returnvalue.py
+++ b/src/writer/blocks/returnvalue.py
@@ -1,6 +1,6 @@
 from writer.abstract import register_abstract_template
 from writer.blocks.base_block import WorkflowBlock
-from writer.ss_types import AbstractTemplate
+from writer.ss_types import AbstractTemplate, WriterConfigurationError
 
 
 class ReturnValue(WorkflowBlock):
@@ -40,7 +40,7 @@ def run(self):
         try:
             value = self._get_field("value")
             if value is None:
-                raise ValueError("Return value cannot be empty or None.")
+                raise WriterConfigurationError("Return value cannot be empty or None.")
             self.result = value
             self.return_value = value
             self.outcome = "success"
diff --git a/src/writer/blocks/setstate.py b/src/writer/blocks/setstate.py
index 78964c3a9..0249df136 100644
--- a/src/writer/blocks/setstate.py
+++ b/src/writer/blocks/setstate.py
@@ -42,8 +42,9 @@ def register(cls, type: str):
 
     def run(self):
         try:
-            element = self._get_field("element")
+            element = self._get_field("element", required=True)
             value = self._get_field("value")
+
             self._set_state(element, value)
             self.result = value
             self.outcome = "success"
diff --git a/src/writer/blocks/writeraddchatmessage.py b/src/writer/blocks/writeraddchatmessage.py
index 5b7a13cf7..e4d8ebe24 100644
--- a/src/writer/blocks/writeraddchatmessage.py
+++ b/src/writer/blocks/writeraddchatmessage.py
@@ -1,6 +1,6 @@
 from writer.abstract import register_abstract_template
 from writer.blocks.base_block import WorkflowBlock
-from writer.ss_types import AbstractTemplate
+from writer.ss_types import AbstractTemplate, WriterConfigurationError
 
 
 class WriterAddChatMessage(WorkflowBlock):
@@ -45,33 +45,19 @@ def run(self):
         try:
             import writer.ai
 
-            conversation_state_element = self._get_field("conversationStateElement")
-            message = self._get_field("message", as_json=True)
-            conversation = self.runner.evaluator.evaluate_expression(conversation_state_element, self.instance_path, self.execution_environment)
+            conversation_state_element = self._get_field("conversationStateElement", required=True)
+            message = self._get_field("message", as_json=True, required=True)
 
-            if conversation is None or not isinstance(conversation, writer.ai.Conversation):
-                self.result = "The state element specified doesn't contain a conversation. Initialize one using the block 'Initialize chat'."
-                self.outcome = "error"
-                return
+            conversation = self.evaluator.evaluate_expression(conversation_state_element, self.instance_path, self.execution_environment)
 
-            if message is None:
-                self.result = "No message has been specified."
-                self.outcome = "error"
-                return
+            if conversation is None or not isinstance(conversation, writer.ai.Conversation):
+                raise WriterConfigurationError("The state element specified doesn't contain a conversation. Initialize one using the block 'Initialize chat'.")
             
-            try:
-                writer.ai.Conversation.validate_message(message)
-            except ValueError:
-                self.result = "Invalid message."
-                self.outcome = "error"
-            finally:
-                if self.outcome:
-                    return            
-
+            writer.ai.Conversation.validate_message(message)
             conversation += message
 
             self._set_state(conversation_state_element, conversation)            
-            self.result = "Success"
+            self.result = None
             self.outcome = "success"
         except BaseException as e:
             self.outcome = "error"
diff --git a/src/writer/blocks/writerchat.py b/src/writer/blocks/writerchat.py
index 62d59d2d0..4a3f73f7a 100644
--- a/src/writer/blocks/writerchat.py
+++ b/src/writer/blocks/writerchat.py
@@ -60,12 +60,11 @@ def register(cls, type: str):
     def _make_callable(self, tool_name: str):
         def callable(**args):
             expanded_execution_environment = self.execution_environment | args
-            return_value = self.run_branch(self.component.id, f"tools_{tool_name}", expanded_execution_environment)
+            return_value = self.runner.run_branch(self.component_id, f"tools_{tool_name}", expanded_execution_environment, f"Workflow branch execution (chat tool {tool_name})")
 
             if return_value is None:
-                self.result = f'No value has been returned for the outcome branch "{tool_name}". Use the block "Return value" to specify one.'
                 self.outcome = "error"
-                raise ValueError(f'No value has been returned for the outcome branch "{tool_name}".')
+                raise ValueError(f'No value has been returned for the outcome branch "{tool_name}". Use the block "Return value" to specify one.')
 
             return return_value
         return callable
@@ -74,7 +73,7 @@ def run(self):
         try:
             import writer.ai
 
-            conversation_state_element = self._get_field("conversationStateElement")
+            conversation_state_element = self._get_field("conversationStateElement", required=True)
             use_streaming = self._get_field("useStreaming", False, "yes") == "yes"
             tools_raw = self._get_field("tools", True)
             tools = []
@@ -99,37 +98,26 @@ def run(self):
                     continue
                 tools.append(tool)
 
-            conversation = self.runner.evaluator.evaluate_expression(conversation_state_element, self.instance_path, self.execution_environment)
+            conversation = self.evaluator.evaluate_expression(conversation_state_element, self.instance_path, self.execution_environment)
 
             if conversation is None or not isinstance(conversation, writer.ai.Conversation):
-                self.result = "The state element specified doesn't contain a conversation. Initialize one using the block 'Initialize chat'."
-                self.outcome = "error"
-                return
+                raise ValueError("The state element specified doesn't contain a conversation. Initialize one using the block 'Initialize chat'.")
 
-            try:
-                msg = ""
-                if not use_streaming:
-                    msg = conversation.complete(tools=tools)
-                    conversation += msg
-                    self._set_state(conversation_state_element, conversation)
-                else:
-                    for chunk in conversation.stream_complete(tools=tools):
-                        if chunk.get("content") is None:
-                            chunk["content"] = ""
-                        msg += chunk.get("content")
-                        conversation += chunk
-                        self._set_state(conversation_state_element, conversation)
-            except BaseException:
-                msg = {
-                    "role": "assistant",
-                    "content": "Couldn't process the request."
-                }
+            msg = ""
+            if not use_streaming:
+                msg = conversation.complete(tools=tools)
                 conversation += msg
                 self._set_state(conversation_state_element, conversation)
+            else:
+                for chunk in conversation.stream_complete(tools=tools):
+                    if chunk.get("content") is None:
+                        chunk["content"] = ""
+                    msg += chunk.get("content")
+                    conversation += chunk
+                    self._set_state(conversation_state_element, conversation)
             
-            if not self.outcome:
-                self.result = msg
-                self.outcome = "success"
+            self.result = msg
+            self.outcome = "success"
         except BaseException as e:
             self.outcome = "error"
             raise e
\ No newline at end of file
diff --git a/src/writer/blocks/writerclassification.py b/src/writer/blocks/writerclassification.py
index 09736fb11..690159ac8 100644
--- a/src/writer/blocks/writerclassification.py
+++ b/src/writer/blocks/writerclassification.py
@@ -33,8 +33,9 @@ def register(cls, type: str):
                     },
                 },
                 "outs": {
-                    "$dynamic": {
-                        "field": "categories"
+                    "category": {
+                        "field": "categories",
+                        "style": "dynamic"
                     },
                     "error": {
                         "name": "Error",
@@ -49,14 +50,11 @@ def run(self):
         try:
             import writer.ai
 
-            text = self._get_field("text")
+            text = self._get_field("text", required=True)
             additional_context = self._get_field("additionalContext")
-            categories = self._get_field("categories", as_json=True)
-            # model_id = self._get_field("modelId")
+            categories = self._get_field("categories", as_json=True, required=True)
 
             config = {}
-            # if model_id:
-            #     config["model"] = model_id
 
             prompt = f"""
 Classify the text under “CONTENT” into one of the following categories:
@@ -75,7 +73,7 @@ def run(self):
 """
             result = writer.ai.complete(prompt, config).strip()
             self.result = result
-            self.outcome = f"$dynamic_{result}"
+            self.outcome = f"category_{result}"
         except BaseException as e:
             self.outcome = "error"
             raise e
\ No newline at end of file
diff --git a/src/writer/blocks/writerinitchat.py b/src/writer/blocks/writerinitchat.py
index ebeef6b6a..de560420d 100644
--- a/src/writer/blocks/writerinitchat.py
+++ b/src/writer/blocks/writerinitchat.py
@@ -1,6 +1,6 @@
 from writer.abstract import register_abstract_template
 from writer.blocks.base_block import WorkflowBlock
-from writer.ss_types import AbstractTemplate
+from writer.ss_types import AbstractTemplate, WriterConfigurationError
 
 DEFAULT_MODEL = "palmyra-x-004"
 
@@ -57,14 +57,12 @@ def run(self):
             model_id = self._get_field("modelId", False, default_field_value=DEFAULT_MODEL)
             config = { "temperature": temperature, "model": model_id}
 
-            conversation = self.runner.evaluator.evaluate_expression(conversation_state_element, self.instance_path, self.execution_environment)
+            conversation = self.evaluator.evaluate_expression(conversation_state_element, self.instance_path, self.execution_environment)
 
             if conversation is not None and not isinstance(conversation, writer.ai.Conversation):
-                self.result = f'The state element specified does not contain a Conversation. A value of type "{type(conversation)}" was found.'
-                self.outcome = "error"
-                return
+                raise WriterConfigurationError(f'The state element specified does not contain a Conversation. A value of type "{type(conversation)}" was found.')
             elif conversation is not None:
-                self.result = "The conversation already exists."
+                self.result = "The conversation already exists. It will not be overwritten."
                 self.outcome = "success"
                 return
 
diff --git a/src/writer/blocks/writernocodeapp.py b/src/writer/blocks/writernocodeapp.py
index 8d222a398..1f505739d 100644
--- a/src/writer/blocks/writernocodeapp.py
+++ b/src/writer/blocks/writernocodeapp.py
@@ -45,7 +45,7 @@ def run(self):
         try:
             import writer.ai
 
-            application_id = self._get_field("appId")
+            application_id = self._get_field("appId", required=True)
             app_inputs = self._get_field("appInputs", as_json=True)
 
             # config = {}
diff --git a/src/writer/core.py b/src/writer/core.py
index 5f044c891..72c03c3c7 100644
--- a/src/writer/core.py
+++ b/src/writer/core.py
@@ -1597,9 +1597,9 @@ def fn(payload, context, session):
                 "session": session
             }
             if workflow_key:
-                self.workflow_runner.run_workflow_by_key( workflow_key, execution_environment)
+                self.workflow_runner.run_workflow_by_key(workflow_key, execution_environment)
             elif workflow_id:
-                self.workflow_runner.run_workflow(workflow_id, execution_environment)
+                self.workflow_runner.run_workflow(workflow_id, execution_environment, "Workflow execution triggered on demand")
         return fn
 
     def _get_handler_callable(self, target_component: Component, event_type: str) -> Optional[Callable]:        
diff --git a/src/writer/evaluator.py b/src/writer/evaluator.py
index 203d4060e..a626bdc94 100644
--- a/src/writer/evaluator.py
+++ b/src/writer/evaluator.py
@@ -112,29 +112,27 @@ def get_context_data(self, instance_path: InstancePath, base_context={}) -> Dict
 
     def set_state(self, expr: str, instance_path: InstancePath, value: Any, base_context = {}) -> None:
         accessors = self.parse_expression(expr, instance_path, base_context)
-        state_ref: writer.core.StateProxy = self.state.user_state
-        leaf_state_ref: writer.core.StateProxy = state_ref
+        state_ref = self.state
 
         for accessor in accessors[:-1]:
-            if isinstance(state_ref, writer.core.StateProxy):
-                leaf_state_ref = state_ref
-
             if isinstance(state_ref, list):
                 state_ref = state_ref[int(accessor)]
             else:
                 state_ref = state_ref[accessor]
 
-        if not isinstance(state_ref, (writer.core.StateProxy, dict)):
+        if not isinstance(state_ref, (writer.core.State, writer.core.WriterState, writer.core.StateProxy, dict)):
             raise ValueError(
-                f"Incorrect state reference. Reference \"{expr}\" isn't part of a StateProxy or dict.")
+                f'Reference "{expr}" cannot be translated to state. Found value of type "{type(state_ref)}".')
 
-        state_ref[accessors[-1]] = value
-        leaf_state_ref.apply_mutation_marker(recursive=True)
+        state_ref[accessors[-1]] = value        
 
     def parse_expression(self, expr: str, instance_path: Optional[InstancePath] = None, base_context = {}) -> List[str]:
 
         """ Returns a list of accessors from an expression. """
 
+        if not isinstance(expr, str):
+            raise ValueError(f'Expression must be of type string. Value of type "{ type(expr) }" found.')
+
         accessors: List[str] = []
         s = ""
         level = 0
diff --git a/src/writer/ss_types.py b/src/writer/ss_types.py
index 397fe52d9..0cad40f6b 100644
--- a/src/writer/ss_types.py
+++ b/src/writer/ss_types.py
@@ -210,4 +210,8 @@ class ComponentDefinition(TypedDict):
     y: Optional[int]
 
 class WorkflowExecutionLog(BaseModel):
-    summary: List[Dict]
\ No newline at end of file
+    summary: List[Dict]
+
+
+class WriterConfigurationError(ValueError):
+    pass
\ No newline at end of file
diff --git a/src/writer/workflows.py b/src/writer/workflows.py
index 2c5e23ecd..38949de68 100644
--- a/src/writer/workflows.py
+++ b/src/writer/workflows.py
@@ -5,53 +5,53 @@
 import writer.blocks.base_block
 import writer.core
 import writer.core_ui
-from writer.ss_types import WorkflowExecutionLog
+from writer.ss_types import WorkflowExecutionLog, WriterConfigurationError
 
 
 class WorkflowRunner():
 
     def __init__(self, session: writer.core.WriterSession):
         self.session = session
-        self.state = session.session_state
-        self.component_tree = session.session_component_tree
 
     def run_workflow_by_key(self, workflow_key: str, execution_environment: Dict = {}):
-        all_components = self.component_tree.components.values()
+        all_components = self.session.session_component_tree.components.values()
         workflows = list(filter(lambda c: c.type == "workflows_workflow" and c.content.get("key") == workflow_key, all_components))
         if len(workflows) == 0:
             raise ValueError(f'Workflow with key "{workflow_key}" not found.')
         workflow = workflows[0]
-        return self.run_workflow(workflow.id, execution_environment)
+        return self.run_workflow(workflow.id, execution_environment, f"Workflow execution ({workflow_key})")
 
     def _get_workflow_nodes(self, component_id):
-        return self.component_tree.get_descendents(component_id)
+        return self.session.session_component_tree.get_descendents(component_id)
 
-    def _get_branch_nodes(self, base_component_id: str, base_outcome: str):
-        base_component = self.component_tree.get_component(base_component_id)
-        if not base_component:
+    def _get_branch_nodes(self, base_component_id: str, base_outcome: Optional[str]=None):
+        root_node = self.session.session_component_tree.get_component(base_component_id)
+        if not root_node:
             raise RuntimeError(f'Cannot obtain branch. Could not find component "{base_component_id}".')
-        outs = base_component.outs
-        nodes:List[writer.core_ui.Component] = []
-        if not outs:
-            return nodes
-        for out in outs:
-            if out.get("outId") == base_outcome:
-                component_id = out.get("toNodeId")
-                component = self.component_tree.get_component(component_id)
-                if not component:
-                    continue
-                nodes.append(component)
-        return nodes
-
-    def run_branch(self, base_component_id: str, base_outcome: str, execution_environment: Dict):
+        if not root_node:
+            return []
+        branch_nodes: List[writer.core_ui.Component] = []
+        if not root_node.outs:
+            return branch_nodes
+        for out in root_node.outs:
+            if base_outcome is not None and base_outcome != out.get("outId"):
+                continue
+            branch_root_node = self.session.session_component_tree.get_component(out.get("toNodeId"))
+            if not branch_root_node:
+                continue
+            branch_nodes.append(branch_root_node)
+            branch_nodes += self._get_branch_nodes(out.get("toNodeId"), base_outcome=None)
+        return branch_nodes
+
+    def run_branch(self, base_component_id: str, base_outcome: str, execution_environment: Dict, title: str = "Branch execution"):
         nodes = self._get_branch_nodes(base_component_id, base_outcome)
-        return self.run_nodes(nodes, execution_environment)
+        return self.run_nodes(nodes, execution_environment, title)
 
-    def run_workflow(self, component_id: str, execution_environment: Dict):
+    def run_workflow(self, component_id: str, execution_environment: Dict, title="Workflow execution"):
         nodes = self._get_workflow_nodes(component_id)
-        return self.run_nodes(nodes, execution_environment)
+        return self.run_nodes(nodes, execution_environment, title)
 
-    def run_nodes(self, nodes: List[writer.core_ui.Component], execution_environment: Dict):
+    def run_nodes(self, nodes: List[writer.core_ui.Component], execution_environment: Dict, title: str = "Workflow execution"):
         execution: Dict[str, writer.blocks.base_block.WorkflowBlock] = {}
         return_value = None
         try:
@@ -60,11 +60,14 @@ def run_nodes(self, nodes: List[writer.core_ui.Component], execution_environment
             for tool in execution.values():
                 if tool and tool.return_value is not None:
                     return_value = tool.return_value
+        except WriterConfigurationError:
+            self._generate_run_log(execution, title, "error")
+            # No need to re-raise, it's a configuration error under control and shown as message in the relevant tool
         except BaseException as e:
-            self._generate_run_log(execution, "Failed workflow execution", "error")
+            self._generate_run_log(execution, title, "error")
             raise e
         else:
-            self._generate_run_log(execution, "Workflow execution", "info", return_value)
+            self._generate_run_log(execution, title, "info", return_value)
         return return_value
 
     def _generate_run_log(self,
@@ -79,13 +82,15 @@ def _generate_run_log(self,
             exec_log.summary.append({
                 "componentId": component_id,
                 "outcome": tool.outcome,
+                "message": tool.message,
                 "result": tool.result,
                 "returnValue": tool.return_value,
                 "executionEnvironment": tool.execution_environment,
                 "executionTimeInSeconds": tool.execution_time_in_seconds 
             })
         msg = "Execution finished."
-        self.state.add_log_entry(entry_type, title, msg, workflow_execution=exec_log)
+        
+        self.session.session_state.add_log_entry(entry_type, title, msg, workflow_execution=exec_log)
 
 
     def get_terminal_nodes(self, nodes):
@@ -143,15 +148,19 @@ def run_node(self, target_node: writer.core_ui.Component, nodes: List[writer.cor
             "result": result,
             "results": { k:v.result for k,v in execution.items() }
         }
-        tool = tool_class(target_node, self, expanded_execution_environment)
+        tool = tool_class(target_node.id, self, expanded_execution_environment)
         
         try:
             start_time = time.time()
             tool.run()
             tool.execution_time_in_seconds = time.time() - start_time
         except BaseException as e:
-            if tool and not tool.result:
-                tool.result = repr(e)
+            if not tool:
+                raise e
+            if not tool.outcome:
+                tool.outcome = "error"
+            if isinstance(e, WriterConfigurationError):
+                tool.message = str(e)
             if not tool.outcome or not self._is_outcome_managed(target_node, tool.outcome):
                 raise e
         finally:
diff --git a/tests/backend/blocks/conftest.py b/tests/backend/blocks/conftest.py
new file mode 100644
index 000000000..d41f61e6f
--- /dev/null
+++ b/tests/backend/blocks/conftest.py
@@ -0,0 +1,52 @@
+from typing import Dict
+
+import pytest
+from writer.core import WriterSession, WriterState
+from writer.core_ui import Branch, Component, ComponentTree, ComponentTreeBranch
+from writer.workflows import WorkflowRunner
+
+
+class BlockTesterMockSession(WriterSession):
+
+    def __init__(self):
+        self.session_state = WriterState({})
+        self.bmc_branch = ComponentTreeBranch(Branch.bmc)
+        component_tree = ComponentTree([self.bmc_branch])
+        self.session_component_tree = component_tree
+
+    def add_fake_component(self, content={}, id="fake_id", type="fake_type"):
+        self.bmc_branch.attach(Component(id=id, type=type, content=content))
+
+
+class BlockTesterMockWorkflowRunner(WorkflowRunner):
+
+    def __init__(self, session):
+        super().__init__(session)
+
+    def run_branch(self, component_id: str, base_outcome_id: str, execution_environment: Dict, title: str):
+        return f"Branch run {component_id} {base_outcome_id}"
+
+    def run_workflow_by_key(self, workflow_key: str, execution_environment: Dict):
+        if "env_injection_test" in execution_environment:
+            return execution_environment.get("env_injection_test")
+        if workflow_key == "workflow1":
+            return 1
+        if workflow_key == "workflowDict":
+            return { "a": "b" }
+        if workflow_key == "duplicator":
+            return execution_environment.get("item") * 2
+        if workflow_key == "showId":
+            return execution_environment.get("itemId")
+        if workflow_key == "boom":
+            return 1/0
+        raise ValueError("Workflow not found.")
+
+
+@pytest.fixture
+def session():
+    yield BlockTesterMockSession()
+
+
+@pytest.fixture
+def runner(session):
+    yield BlockTesterMockWorkflowRunner(session)
diff --git a/tests/backend/blocks/test_addtostatelist.py b/tests/backend/blocks/test_addtostatelist.py
new file mode 100644
index 000000000..ffc222548
--- /dev/null
+++ b/tests/backend/blocks/test_addtostatelist.py
@@ -0,0 +1,37 @@
+import pytest
+from writer.blocks.addtostatelist import AddToStateList
+from writer.workflows import WorkflowRunner
+
+
+def test_empty_list(session, runner):
+    session.add_fake_component({
+        "element": "my_list",
+        "value": "my_value"
+    })
+    block = AddToStateList("fake_id", runner, {})
+    block.run()
+    assert block.outcome == "success"
+    assert session.session_state["my_list"] == ["my_value"]
+
+def test_non_empty_list(session, runner):
+    session.session_state["my_list"] = ["a"]
+    session.add_fake_component({
+        "element": "my_list",
+        "value": "b"
+    })
+    block = AddToStateList("fake_id", runner, {})
+    block.run()
+    assert block.outcome == "success"
+    assert session.session_state["my_list"] == ["a", "b"]
+
+
+def test_non_list_element(session, runner):
+    session.session_state["my_element"] = "dog"
+    session.add_fake_component({
+        "element": "my_element",
+        "value": "cat"
+    })
+    block = AddToStateList("fake_id", runner, {})
+    with pytest.raises(ValueError):
+        block.run()
+    assert block.outcome == "error"
\ No newline at end of file
diff --git a/tests/backend/blocks/test_base_block.py b/tests/backend/blocks/test_base_block.py
new file mode 100644
index 000000000..b044e7c93
--- /dev/null
+++ b/tests/backend/blocks/test_base_block.py
@@ -0,0 +1,44 @@
+from writer.blocks.base_block import WorkflowBlock
+from writer.core import WriterState
+
+
+def test_get_field(session, runner):
+    session.session_state = WriterState({
+        "animal": "rat",
+        "my_list": "[1,2,3]",
+        "my_dict": '{ "a": "b" }'
+    })
+    session.add_fake_component({
+        "my_element": "@{animal}",
+        "my_list": "@{my_list}",
+        "my_dict": "@{my_dict}"
+    })
+    block = WorkflowBlock("fake_id", runner, {})
+    assert "rat" == block._get_field("my_element", as_json=False, default_field_value="elephant")
+    assert [1, 2, 3] == block._get_field("my_list", as_json=True, default_field_value=None)
+    assert "b" == block._get_field("my_dict", as_json=True, default_field_value=None).get("a")
+    assert "ok" == block._get_field("ghost_field", as_json=False, default_field_value="ok")
+    assert {} == block._get_field("ghost_field", as_json=True)
+    assert "ok" == block._get_field("ghost_field_json", as_json=True, default_field_value='{ "ok": "ok" }').get("ok")
+    block.run()
+    assert block.outcome is None
+
+
+def test_set_state(session, runner):
+    session.session_state = WriterState({
+        "animal": "rat",
+        "my_list": [1,2,4],
+        "my_dict": { "animal": "dog"},
+        "unchanged": "unchanged"
+    })
+    block = WorkflowBlock("fake_id", runner, {})
+    block._set_state("animal", "cat")
+    block._set_state("animal", "bat")
+    block._set_state("my_list", [1, 2])
+    block._set_state("my_dict", { "animal": "cat"})
+    block.run()
+    assert session.session_state["animal"] == "bat"
+    assert session.session_state["my_list"] == [1, 2]
+    assert session.session_state["my_dict"]["animal"] == "cat"
+    assert session.session_state["unchanged"] == "unchanged"
+    assert block.outcome is None
\ No newline at end of file
diff --git a/tests/backend/blocks/test_calleventhandler.py b/tests/backend/blocks/test_calleventhandler.py
new file mode 100644
index 000000000..726418fb8
--- /dev/null
+++ b/tests/backend/blocks/test_calleventhandler.py
@@ -0,0 +1,48 @@
+import pytest
+import writer.core
+from writer.blocks.calleventhandler import CallEventHandler
+
+
+def valid_handler(state):
+    state["animal"] = "duck"
+    return 1
+
+def invalid_handler(state):
+    state["animal"] = "cat"
+    return 1/0
+
+class MockHandlerRegistry():
+
+    def find_handler_callable(self, handler_name: str):
+        if handler_name == "valid_handler":
+            return valid_handler
+        elif handler_name == "invalid_handler":
+            return invalid_handler
+        raise None
+
+class MockAppProcess():
+    
+    def __init__(self):
+        self.handler_registry = MockHandlerRegistry()
+
+def test_call_event_handler(session, runner):
+    writer.core.get_app_process = lambda: MockAppProcess()
+    session.add_fake_component({
+        "name": "valid_handler"
+    })
+    block = CallEventHandler("fake_id", runner, {})
+    block.run()
+    assert block.outcome == "success"
+    assert block.result == 1
+    assert session.session_state["animal"] == "duck"
+
+def test_invalid_json(session, runner):
+    writer.core.get_app_process = lambda: MockAppProcess()
+    session.add_fake_component({
+        "name": "invalid_handler"
+    })
+    block = CallEventHandler("fake_id", runner, {})
+    with pytest.raises(BaseException):
+        block.run()
+    assert block.outcome == "error"
+    assert session.session_state["animal"] == "cat"
\ No newline at end of file
diff --git a/tests/backend/blocks/test_foreach.py b/tests/backend/blocks/test_foreach.py
new file mode 100644
index 000000000..2377959f2
--- /dev/null
+++ b/tests/backend/blocks/test_foreach.py
@@ -0,0 +1,53 @@
+import pytest
+from writer.blocks.foreach import ForEach
+
+
+def test_basic_list(session, runner):
+    session.add_fake_component({
+        "workflowKey": "workflow1",
+        "items": "[2, 2, 2, 2]"
+    })
+    block = ForEach("fake_id", runner, {})
+    block.run()
+    assert block.outcome == "success"
+    assert block.result == [1, 1, 1, 1]
+
+def test_list_of_dict(session, runner):
+    session.add_fake_component({
+        "workflowKey": "workflowDict",
+        "items": "[2, 2]"
+    })
+    block = ForEach("fake_id", runner, {})
+    block.run()
+    assert block.outcome == "success"
+    assert block.result == [{"a": "b"}, {"a": "b"}]
+
+def test_basic_dict(session, runner):
+    session.add_fake_component({
+        "workflowKey": "workflow1",
+        "items": '{"a": "zzz", "b": "zzz"}'
+    })
+    block = ForEach("fake_id", runner, {})
+    block.run()
+    assert block.outcome == "success"
+    assert block.result == {"a": 1, "b": 1}
+
+def test_workflow_that_does_not_exist(session, runner):
+    session.add_fake_component({
+        "workflowKey": "workflowThatDoesNotExist",
+        "items": '{"a": "zzz", "b": "zzz"}'
+    })
+    block = ForEach("fake_id", runner, {})
+    with pytest.raises(ValueError):
+        block.run()
+    assert block.outcome == "error"
+
+def test_duplicator(session, runner):
+    session.add_fake_component({
+        "workflowKey": "duplicator",
+        "items": '{"a": 1, "b": 2, "c": 11}'
+    })
+    block = ForEach("fake_id", runner, {})
+    block.run()
+    assert block.outcome == "success"
+    assert block.result == {"a": 2, "b": 4, "c": 22}
\ No newline at end of file
diff --git a/tests/backend/blocks/test_httprequest.py b/tests/backend/blocks/test_httprequest.py
new file mode 100644
index 000000000..3d3388ff0
--- /dev/null
+++ b/tests/backend/blocks/test_httprequest.py
@@ -0,0 +1,121 @@
+import json
+
+import pytest
+import requests
+from writer.blocks.httprequest import HTTPRequest
+
+
+class FakeResponse():
+    def __init__(self, status_code=200, ok=True, headers={}, text=None):
+        self.status_code = status_code
+        self.ok = ok
+        self.headers = headers
+        self.text = text
+        self.json = lambda: json.loads(text)
+
+
+def fake_request(method, url, headers={}, data=""):
+    if not headers.get("TestHeader", "not-a-sec-ret"):
+        raise RuntimeError("Test header not present.")
+    if method == "GET" and url == "https://www.duck.com":
+        return FakeResponse(
+            headers={"Content-Type": "text/plain"},
+            text="Ducks are birds."
+        )
+    if method == "POST" and url == "https://www.elephant.com":
+        return FakeResponse(
+            headers={"Content-Type": "application/json"},
+            text='{ "elephant_name": "Momo", "request_body": "' + data + '" }'
+        )
+    if method == "POST" and url == "https://www.elephant.com/history":
+        return FakeResponse(
+            status_code=404,
+            ok=False,
+            headers={"Content-Type": "application/json"},
+            text='{ "error_message": "Page not found." }'
+        )
+
+    raise requests.ConnectionError()
+
+
+@pytest.mark.explicit
+def test_actual_request(session, runner):
+    session.add_fake_component({
+        "url": 'https://www.example.com'
+    })
+    block = HTTPRequest("fake_id", runner, {})
+    block.run()
+    assert block.outcome == "success"
+    assert block.result.get("headers") is not None
+
+
+@pytest.mark.explicit
+def test_actual_failing_request(session, runner):
+    session.add_fake_component({
+        "url": 'https://www.site-that-does-not-exist-3017673369.com'
+    })
+    block = HTTPRequest("fake_id", runner, {})
+    with pytest.raises(requests.ConnectionError):
+        block.run()
+    assert block.outcome == "connectionError"
+
+
+@pytest.mark.explicit
+def test_actual_request_with_bad_path(session, runner):
+    session.add_fake_component({
+        "url": 'https://www.writer.com/3017673369'
+    })
+    block = HTTPRequest("fake_id", runner, {})
+    with pytest.raises(RuntimeError):
+        block.run()
+    assert block.outcome == "responseError"
+
+
+def test_patched_request(session, runner):
+    requests.request = fake_request
+    session.add_fake_component({
+        "url": "https://www.duck.com"
+    })
+    block = HTTPRequest("fake_id", runner, {})
+    block.run()
+    assert block.outcome == "success"
+    assert block.result.get("body") == "Ducks are birds."
+
+
+def test_patched_request_to_nowhere(session, runner):
+    requests.request = fake_request
+    session.add_fake_component({
+        "url": "https://www.cat.com"
+    })
+    block = HTTPRequest("fake_id", runner, {})
+    with pytest.raises(requests.ConnectionError):
+        block.run()
+    assert block.outcome == "connectionError"
+
+
+def test_patched_request_with_json(session, runner):
+    requests.request = fake_request
+    session.add_fake_component({
+        "url": "https://www.elephant.com",
+        "method": "POST",
+        "body": "Posting the elephant."
+    })
+    block = HTTPRequest("fake_id", runner, {})
+    block.run()
+    assert block.outcome == "success"
+    assert block.result.get("body").get("elephant_name") == "Momo"
+    assert block.result.get("body").get("request_body") == "Posting the elephant."
+
+
+def test_patched_request_with_json_and_bad_path(session, runner):
+    requests.request = fake_request
+    session.add_fake_component({
+        "url": "https://www.elephant.com/history",
+        "method": "POST",
+        "body": "Posting the elephant."
+    })
+    block = HTTPRequest("fake_id", runner, {})
+    with pytest.raises(RuntimeError):
+        block.run()
+    assert block.outcome == "responseError" # due to not "ok"
+    assert block.result.get("body").get("error_message") == "Page not found."
diff --git a/tests/backend/blocks/test_logmessage.py b/tests/backend/blocks/test_logmessage.py
new file mode 100644
index 000000000..76f1b90cd
--- /dev/null
+++ b/tests/backend/blocks/test_logmessage.py
@@ -0,0 +1,73 @@
+import pytest
+import writer.core
+from writer.blocks.logmessage import LogMessage
+from writer.core import WriterState
+
+
+def test_log_message(session, runner):
+    session.session_state = WriterState({
+        "animal": "rat",
+    }, [{"type": "test", "payload": "Just a test"}])
+    session.add_fake_component({
+        "message": "The quick brown fox is under the table."
+    })
+    writer.core.Config.is_mail_enabled_for_log = True
+    block = LogMessage("fake_id", runner, {})
+    block.run()
+    assert block.outcome == "success"
+    latest_mail = session.session_state.mail[0]
+    assert latest_mail.get("type") == "logEntry"
+    assert latest_mail.get("payload").get("type") == "info"
+    assert latest_mail.get("payload").get("message") == "The quick brown fox is under the table."
+
+
+def test_log_message_with_template(session, runner):
+    session.session_state = WriterState({
+        "animal": "rat",
+    })
+    session.add_fake_component({
+        "message": "The quick brown @{animal} is under the @{object}."
+    })
+    writer.core.Config.is_mail_enabled_for_log = True
+    block = LogMessage("fake_id", runner, {
+        "object": "tent"
+    })
+    block.run()
+    assert block.outcome == "success"
+    latest_mail = session.session_state.mail[0]
+    assert latest_mail.get("type") == "logEntry"
+    assert latest_mail.get("payload").get("type") == "info"
+    assert latest_mail.get("payload").get("message") == "The quick brown rat is under the tent."
+
+
+def test_log_error_message(session, runner):
+    session.session_state = WriterState({
+        "animal": "squirrel",
+    })
+    session.add_fake_component({
+        "type": "error",
+        "message": "The quick brown @{animal} has escaped."
+    })
+    writer.core.Config.is_mail_enabled_for_log = True
+    block = LogMessage("fake_id", runner, {})
+    block.run()
+    assert block.outcome == "success"
+    latest_mail = session.session_state.mail[0]
+    assert latest_mail.get("type") == "logEntry"
+    assert latest_mail.get("payload").get("type") == "error"
+    assert latest_mail.get("payload").get("message") == "The quick brown squirrel has escaped."
+
+
+def test_empty_message(session, runner):
+    session.session_state = WriterState({
+        "animal": None,
+    })
+    session.add_fake_component({
+        "type": "error",
+        "message": "@{animals}"
+    })
+    writer.core.Config.is_mail_enabled_for_log = True
+    block = LogMessage("fake_id", runner, {})
+    with pytest.raises(ValueError):
+        block.run()
+    assert block.outcome == "error"
\ No newline at end of file
diff --git a/tests/backend/blocks/test_parsejson.py b/tests/backend/blocks/test_parsejson.py
index e7eefca62..ae13f0bd9 100644
--- a/tests/backend/blocks/test_parsejson.py
+++ b/tests/backend/blocks/test_parsejson.py
@@ -1,6 +1,25 @@
+import json
+
+import pytest
 from writer.blocks.parsejson import ParseJSON
+from writer.workflows import WorkflowRunner
+
+
+def test_valid_json(session, runner):
+    session.add_fake_component({
+        "plainText": '{ "hi": "yes" }'
+    })
+    block = ParseJSON("fake_id", runner, {})
+    block.run()
+    assert block.outcome == "success"
+    assert block.result.get("hi") == "yes"
 
+def test_invalid_json(session, runner):
+    session.add_fake_component({
+        "plainText": '{ "hi": yes }'
+    })
+    block = ParseJSON("fake_id", runner, {})
+    with pytest.raises(json.JSONDecodeError):
+        block.run()
 
-def test_valid_json():
-    assert 1 == 1
-    # tool = ParseJSON()
\ No newline at end of file
+    assert block.outcome == "error"
\ No newline at end of file
diff --git a/tests/backend/blocks/test_returnvalue.py b/tests/backend/blocks/test_returnvalue.py
new file mode 100644
index 000000000..13d3427cc
--- /dev/null
+++ b/tests/backend/blocks/test_returnvalue.py
@@ -0,0 +1,30 @@
+import pytest
+from writer.blocks.returnvalue import ReturnValue
+from writer.core import WriterState
+
+
+def test_basic_return(session, runner):
+    session.session_state = WriterState({
+        "animal": "marmot",
+    })
+    session.add_fake_component({
+        "value": "@{animal}"
+    })
+    block = ReturnValue("fake_id", runner, {})
+    block.run()
+    assert block.outcome == "success"    
+    assert block.result == block.return_value
+    assert block.return_value == "marmot"
+
+def test_empty_return(session, runner):
+    session.session_state = WriterState({
+        "animal": None,
+    })
+    session.add_fake_component({
+        "value": "@{animal}"
+    })
+    block = ReturnValue("fake_id", runner, {})
+    
+    with pytest.raises(ValueError):
+        block.run()
+    assert block.outcome == "error"
\ No newline at end of file
diff --git a/tests/backend/blocks/test_runworkflow.py b/tests/backend/blocks/test_runworkflow.py
new file mode 100644
index 000000000..2e3a0d90d
--- /dev/null
+++ b/tests/backend/blocks/test_runworkflow.py
@@ -0,0 +1,31 @@
+import pytest
+from writer.blocks.runworkflow import RunWorkflow
+
+
+def test_workflow_that_does_not_exist(session, runner):
+    session.add_fake_component({
+        "workflowKey": "workflowThatDoesNotExist",
+    })
+    block = RunWorkflow("fake_id", runner, {})
+    with pytest.raises(ValueError):
+        block.run()
+    assert block.outcome == "error"
+
+def test_duplicator(session, runner):
+    session.add_fake_component({
+        "workflowKey": "duplicator",
+        "executionEnv": '{"item": 23}'
+    })
+    block = RunWorkflow("fake_id", runner, {})
+    block.run()
+    assert block.outcome == "success"
+    assert block.result == 46
+
+def test_bad_workflow(session, runner):
+    session.add_fake_component({
+        "workflowKey": "boom"
+    })
+    block = RunWorkflow("fake_id", runner, {})
+    with pytest.raises(BaseException):
+        block.run()
+    assert block.outcome == "error"
\ No newline at end of file
diff --git a/tests/backend/blocks/test_setstate.py b/tests/backend/blocks/test_setstate.py
new file mode 100644
index 000000000..82bfbdee3
--- /dev/null
+++ b/tests/backend/blocks/test_setstate.py
@@ -0,0 +1,61 @@
+import pytest
+from writer.blocks.setstate import SetState
+from writer.workflows import WorkflowRunner
+
+
+def test_basic_assignment(session):
+    session.add_fake_component({
+        "element": "my_element",
+        "value": "my_value"
+    })
+    runner = WorkflowRunner(session)
+    block = SetState("fake_id", runner, {})
+    block.run()
+    assert block.outcome == "success"
+    assert session.session_state["my_element"] == "my_value"
+
+def test_nested_assignment_without_parent(session):
+    session.add_fake_component({
+        "element": "parent_element.my_element",
+        "value": "my_value"
+    })
+    runner = WorkflowRunner(session)
+    block = SetState("fake_id", runner, {})
+    with pytest.raises(ValueError):
+        block.run()
+    assert block.outcome == "error"
+
+def test_nested_assignment_with_parent(session, runner):
+    session.session_state["parent_element"] = {
+        "sibling_element": "yes"
+    }
+    session.add_fake_component({
+        "element": "parent_element.my_element",
+        "value": "my_value"
+    })
+    block = SetState("fake_id", runner, {})
+    block.run()
+    assert block.outcome == "success"
+    assert session.session_state["parent_element"]["sibling_element"] == "yes"
+    assert session.session_state["parent_element"]["my_element"] == "my_value"
+
+def test_assignment_with_empty_element(session):
+    session.add_fake_component({
+        "element": "",
+        "value": "my_value"
+    })
+    runner = WorkflowRunner(session)
+    block = SetState("fake_id", runner, {})
+    with pytest.raises(ValueError):
+        block.run()
+    assert block.outcome == "error"
+
+def test_assignment_with_empty_value(session):
+    session.add_fake_component({
+        "element": "my_element",
+        "value": ""
+    })
+    runner = WorkflowRunner(session)
+    block = SetState("fake_id", runner, {})
+    block.run()
+    assert block.outcome == "success"
\ No newline at end of file
diff --git a/tests/backend/blocks/test_writeraddchatmessage.py b/tests/backend/blocks/test_writeraddchatmessage.py
new file mode 100644
index 000000000..34a9db987
--- /dev/null
+++ b/tests/backend/blocks/test_writeraddchatmessage.py
@@ -0,0 +1,50 @@
+import pytest
+import writer.ai
+from writer.blocks.writeraddchatmessage import WriterAddChatMessage
+
+
+def test_add_chat_message(session, runner):
+    session.session_state["convo"] = writer.ai.Conversation()
+    session.add_fake_component({
+        "conversationStateElement": "convo",
+        "message": '{ "role": "user", "content": "hi" }'
+    })
+    block = WriterAddChatMessage("fake_id", runner, {})
+    assert len(session.session_state["convo"].messages) == 0
+    block.run()
+    assert len(session.session_state["convo"].messages) == 1
+
+
+def test_add_chat_message_bad_template(session, runner):
+    session.session_state["convo"] = writer.ai.Conversation()
+    session.add_fake_component({
+        "conversationStateElement": "@{convo}", # Should be convo not @{convo}
+        "message": '{ "role": "user", "content": "hi" }'
+    })
+    block = WriterAddChatMessage("fake_id", runner, {})
+    with pytest.raises(ValueError):
+        block.run()
+
+
+def test_add_chat_message_bad_message(session, runner):
+    session.session_state["convo"] = writer.ai.Conversation()
+    session.add_fake_component({
+        "conversationStateElement": "convo", # Should be convo not @{convo}
+        "message": '{ "x": "user", "content": "hi" }'
+    })
+    block = WriterAddChatMessage("fake_id", runner, {})
+    with pytest.raises(ValueError):
+        block.run()
+
+
+def test_add_chat_message_missing_convo(session, runner):
+    session.session_state["convo"] = None
+    session.add_fake_component({
+        "conversationStateElement": "@{convo}",
+        "message": '{ "role": "user", "content": "hi" }'
+    })
+    block = WriterAddChatMessage("fake_id", runner, {})
+    with pytest.raises(ValueError):
+        block.run()
+
+
diff --git a/tests/backend/blocks/test_writerchat.py b/tests/backend/blocks/test_writerchat.py
new file mode 100644
index 000000000..661d8c2ea
--- /dev/null
+++ b/tests/backend/blocks/test_writerchat.py
@@ -0,0 +1,125 @@
+import json
+
+import pytest
+from writer.ai import Conversation
+from writer.blocks.writerchat import WriterChat
+
+
+class MockConversation(Conversation):
+
+    def __init__(self):
+        super().__init__()
+
+    def _check_tools(self, tools):
+        if tools is None or tools == []:
+            return
+        if len(tools) != 2:
+            raise RuntimeError("Invalid number of tools.")
+        function_tool = tools[0]
+        
+        assert function_tool.get("type") == "function"
+        assert function_tool.get("name") == "bat_locator"
+        assert function_tool.get("description") == "Locates bats."
+        assert function_tool.get("parameters").get("color") == {
+            "type": "string",
+            "description": "The color of the bat you're looking for."
+        }
+        graph_tool = tools[1]
+        assert graph_tool.get("type") == "graph"
+        assert graph_tool.get("graph_ids") == [111, 112, 113]
+
+    def complete(self, tools=None):
+        self._check_tools(tools)
+        return {
+            "role": "assistant",
+            "content": "Next to the grill."
+        }
+    
+    def stream_complete(self, tools=None):
+        self._check_tools(tools)
+        yield {
+            "role": "assistant",
+            "content": "On "
+        }
+        yield {
+            "role": "assistant",
+            "content": "the ",
+            "chunk": True
+        }
+        yield {
+            "role": "assistant",
+            "content": "car's ",
+            "chunk": True
+        }
+        yield {
+            "role": "assistant",
+            "content": "roof.",
+            "chunk": True
+        }
+
+@pytest.fixture
+def conversation():
+    return MockConversation()
+
+def test_chat_complete(session, runner, conversation):
+    conversation.add("user", "Hi, where's the bat?")
+    session.session_state["convo"] = conversation
+    session.add_fake_component({
+        "conversationStateElement": "convo",
+        "useStreaming": "no"
+    })
+    block = WriterChat("fake_id", runner, {})
+    block.run()
+    assert conversation.messages[1].get("content") == "Next to the grill."
+
+
+def test_chat_stream_complete(session, runner, conversation):
+    conversation.add("user", "Hi, where's the bat?")
+    session.session_state["convo"] = conversation
+    session.add_fake_component({
+        "conversationStateElement": "convo"
+        # streaming should be default
+    })
+    block = WriterChat("fake_id", runner, {})
+    block.run()
+    assert conversation.messages[1].get("content") == "On the car's roof."
+
+
+def test_chat_stream_complete_with_tools(session, runner, conversation):
+    conversation.add("user", "Hi, where's the bat?")
+    session.session_state["convo"] = conversation
+    session.add_fake_component({
+        "conversationStateElement": "convo",
+        "tools": json.dumps({
+            "bat_locator": {
+                "type": "function",
+                "description": "Locates bats.",
+                "parameters": {
+                    "color": {
+                        "type": "string",
+                        "description": "The color of the bat you're looking for."
+                    }
+                }
+            },
+            "known_bat_spots": {
+                "type": "graph",
+                "graph_ids": [111, 112, 113]
+            }
+        }),
+        "useStreaming": "yes"
+    })
+    block = WriterChat("fake_id", runner, {})
+    block.run()
+    assert conversation.messages[1].get("content") == "On the car's roof."
+
+
+def test_chat_stream_complete_no_conversation(session, runner, conversation):
+    conversation.add("user", "Hi, where's the bat?")
+    session.session_state["convo"] = "not_a_conversation"
+    session.add_fake_component({
+        "conversationStateElement": "convo"
+        # streaming should be default
+    })
+    block = WriterChat("fake_id", runner, {})
+    with pytest.raises(ValueError):
+        block.run()
\ No newline at end of file
diff --git a/tests/backend/blocks/test_writerclassification.py b/tests/backend/blocks/test_writerclassification.py
new file mode 100644
index 000000000..730968e77
--- /dev/null
+++ b/tests/backend/blocks/test_writerclassification.py
@@ -0,0 +1,42 @@
+import json
+
+import pytest
+import writer.ai
+from writer.blocks.writerclassification import WriterClassification
+
+
+def fake_complete(prompt, config):
+    additional_context = "It's about animal classification."
+    if "canine" in prompt and additional_context in prompt:
+        return "dog"
+    if "feline" in prompt and additional_context in prompt:
+        return "cat"
+    return "other"
+
+
+def test_classify(session, runner):
+    writer.ai.complete = fake_complete
+    session.add_fake_component({
+        "text": "canine",
+        "categories": json.dumps({
+            "cat": "Pertaining to cats.",
+            "dog": "Pertaining to dogs."
+        }),
+        "additionalContext": "It's about animal classification."
+    })
+    block = WriterClassification("fake_id", runner, {})
+    block.run()
+    assert block.result == "dog"
+    assert block.outcome == "category_dog"
+
+
+def test_classify_missing_categories(session, runner):
+    writer.ai.complete = fake_complete
+    session.add_fake_component({
+        "text": "canine",
+        "categories": json.dumps({})
+    })
+    block = WriterClassification("fake_id", runner, {})
+    
+    with pytest.raises(ValueError):
+        block.run()
\ No newline at end of file
diff --git a/tests/backend/blocks/test_writercompletion.py b/tests/backend/blocks/test_writercompletion.py
new file mode 100644
index 000000000..6573a7f8f
--- /dev/null
+++ b/tests/backend/blocks/test_writercompletion.py
@@ -0,0 +1,42 @@
+import writer.ai
+from writer.blocks.writercompletion import WriterCompletion
+
+
+def test_complete(session, runner):
+    def fake_complete(prompt, config):
+        assert config.get("temperature") == 0.9
+        assert config.get("model") == "buenos-aires-x-004"
+        assert prompt == "What color is the sea?"
+        return "Blue."
+
+    writer.ai.complete = fake_complete
+    session.add_fake_component({
+        "prompt": "What color is the sea?",
+        "modelId": "buenos-aires-x-004",
+        "temperature": "0.9"
+    })
+    block = WriterCompletion("fake_id", runner, {})
+    block.run()
+    assert block.result == "Blue."
+    assert block.outcome == "success"
+
+def test_complete_missing_text(session, runner):
+    def fake_complete(prompt, config):
+        assert config.get("temperature") == 0.9
+        assert config.get("model") == "buenos-aires-x-004"
+        assert not prompt
+        return "Plants are usually green."
+
+    writer.ai.complete = fake_complete
+    session.add_fake_component({
+        "prompt": "",
+        "modelId": "buenos-aires-x-004",
+        "temperature": "0.9"
+    })
+    block = WriterCompletion("fake_id", runner, {})
+ 
+    # Not expected to fail, just hallucinate
+
+    block.run()
+    assert block.result == "Plants are usually green."
+    assert block.outcome == "success"
\ No newline at end of file
diff --git a/tests/backend/blocks/test_writerinitchat.py b/tests/backend/blocks/test_writerinitchat.py
new file mode 100644
index 000000000..eb832cd73
--- /dev/null
+++ b/tests/backend/blocks/test_writerinitchat.py
@@ -0,0 +1,33 @@
+import pytest
+from writer.ai import Conversation
+from writer.blocks.writerinitchat import WriterInitChat
+
+
+def test_init_chat_already_initialized(session, runner):
+    session.session_state["convo"] = Conversation()
+    session.add_fake_component({
+        "conversationStateElement": "convo",
+    })
+    block = WriterInitChat("fake_id", runner, {})
+    block.run()
+    assert block.outcome == "success"
+
+
+def test_init_chat_already_initialized_with_rubbish(session, runner):
+    session.session_state["convo"] = "-hello -hello there. This is a conversation but not the right kind."
+    session.add_fake_component({
+        "conversationStateElement": "convo",
+    })
+    block = WriterInitChat("fake_id", runner, {})
+    
+    with pytest.raises(ValueError):
+        block.run()
+
+def test_init_chat_from_scratch(session, runner):
+    session.add_fake_component({
+        "conversationStateElement": "convo",
+    })
+    block = WriterInitChat("fake_id", runner, {})
+    block.run()
+    assert isinstance(session.session_state["convo"], Conversation)
+    assert block.outcome == "success"
\ No newline at end of file
diff --git a/tests/backend/blocks/test_writernocodeapp.py b/tests/backend/blocks/test_writernocodeapp.py
new file mode 100644
index 000000000..3ad96a75a
--- /dev/null
+++ b/tests/backend/blocks/test_writernocodeapp.py
@@ -0,0 +1,43 @@
+import json
+
+import pytest
+import writer.ai
+from writer.blocks.writernocodeapp import WriterNoCodeApp
+
+
+def fake_generate_content(application_id, app_inputs):
+    assert application_id == "123"
+
+    name = app_inputs.get("name")
+    animal = app_inputs.get("animal")
+
+    return f"{name} the {animal}  "
+
+def test_call_nocode_app(session, runner):
+    writer.ai.apps.generate_content = fake_generate_content
+    session.add_fake_component({
+        "appId": "123",
+        "appInputs": json.dumps({
+            "name": "Koko",
+            "animal": "Hamster"    
+        })
+    })
+    block = WriterNoCodeApp("fake_id", runner, {})
+    block.run()
+    assert block.result == "Koko the Hamster"
+    assert block.outcome == "success"
+
+
+def test_call_nocode_app_missing_appid(session, runner):
+    writer.ai.apps.generate_content = fake_generate_content
+    session.add_fake_component({
+        "appId": "",
+        "appInputs": json.dumps({
+            "name": "Momo",
+            "animal": "Squirrel"    
+        })
+    })
+    block = WriterNoCodeApp("fake_id", runner, {})
+    
+    with pytest.raises(ValueError):
+        block.run()
\ No newline at end of file