diff --git a/src/CqlBuilderPanel/CqlBuilderPanel.tsx b/src/CqlBuilderPanel/CqlBuilderPanel.tsx
index 3511c188..9c82fc26 100644
--- a/src/CqlBuilderPanel/CqlBuilderPanel.tsx
+++ b/src/CqlBuilderPanel/CqlBuilderPanel.tsx
@@ -256,12 +256,12 @@ export default function CqlBuilderPanel({
 
           {activeTab === "functions" && (
             <FunctionsSection
+              cqlBuilderLookupsTypes={cqlBuilderLookupsTypes}
               canEdit={canEdit}
               handleApplyFunction={handleApplyFunction}
               loading={loading}
               cql={measureStoreCql}
               isCQLUnchanged={isCQLUnchanged}
-              cqlBuilderLookupsTypes={cqlBuilderLookupsTypes}
             />
           )}
         </div>
diff --git a/src/CqlBuilderPanel/common/utils.tsx b/src/CqlBuilderPanel/common/utils.tsx
new file mode 100644
index 00000000..5c9a0040
--- /dev/null
+++ b/src/CqlBuilderPanel/common/utils.tsx
@@ -0,0 +1,47 @@
+export const formatExpressionName = (values) => {
+  return values?.type !== "Timing" && values?.type !== "Pre-Defined Functions"
+    ? values?.type === "Functions" || values?.type === "Fluent Functions"
+      ? values?.name?.replace(/([\w\s]+)\(\)/g, '"$1"()')
+      : values?.name.includes(".")
+      ? values?.name.replace(/(.*\.)(.*)/, '$1"$2"')
+      : `"${values?.name}"`
+    : values?.name;
+};
+
+export const getNewExpressionsAndLines = (
+  values: any,
+  cursorPosition: any,
+  expressionEditorValue: any,
+  autoInsert: boolean
+) => {
+  const formattedExpression = formatExpressionName(values);
+  let editorExpressionValue = expressionEditorValue;
+  let newCursorPosition = cursorPosition;
+
+  if (cursorPosition && !autoInsert) {
+    // Insert at cursor position
+    const { row, column } = cursorPosition;
+    const lines = expressionEditorValue.split("\n");
+    const currentLine = lines[row];
+    lines[row] =
+      currentLine.slice(0, column) +
+      formattedExpression +
+      currentLine.slice(column);
+    editorExpressionValue = lines.join("\n");
+    newCursorPosition = {
+      row,
+      column: column + formattedExpression.length,
+    } as unknown;
+  } else {
+    // Append to a new line
+    const lines = editorExpressionValue.split("\n");
+    const newLineIndex = lines.length;
+    editorExpressionValue +=
+      (editorExpressionValue ? "\n" : "") + formattedExpression;
+    newCursorPosition = {
+      row: newLineIndex,
+      column: formattedExpression.length,
+    };
+  }
+  return [editorExpressionValue, newCursorPosition];
+};
diff --git a/src/CqlBuilderPanel/definitionsSection/definitionBuilder/DefinitionBuilder.test.tsx b/src/CqlBuilderPanel/definitionsSection/definitionBuilder/DefinitionBuilder.test.tsx
index 04759c27..0f1c9b34 100644
--- a/src/CqlBuilderPanel/definitionsSection/definitionBuilder/DefinitionBuilder.test.tsx
+++ b/src/CqlBuilderPanel/definitionsSection/definitionBuilder/DefinitionBuilder.test.tsx
@@ -3,7 +3,8 @@ import { render, screen, fireEvent, waitFor } from "@testing-library/react";
 import { describe, it } from "@jest/globals";
 import "@testing-library/jest-dom";
 import { within } from "@testing-library/dom";
-import DefinitionBuilder, { formatExpressionName } from "./DefinitionBuilder";
+import DefinitionBuilder from "./DefinitionBuilder";
+import { formatExpressionName } from "../../common/utils";
 import { cqlBuilderLookup } from "../../__mocks__/MockCqlBuilderLookupsTypes";
 
 describe("CQL Definition Builder Tests", () => {
diff --git a/src/CqlBuilderPanel/definitionsSection/definitionBuilder/DefinitionBuilder.tsx b/src/CqlBuilderPanel/definitionsSection/definitionBuilder/DefinitionBuilder.tsx
index a8d47649..250fa29c 100644
--- a/src/CqlBuilderPanel/definitionsSection/definitionBuilder/DefinitionBuilder.tsx
+++ b/src/CqlBuilderPanel/definitionsSection/definitionBuilder/DefinitionBuilder.tsx
@@ -11,6 +11,7 @@ import "../Definitions.scss";
 import { DefinitionSectionSchemaValidator } from "../../../validations/DefinitionSectionSchemaValidator";
 import ExpressionEditor from "../expressionSection/ExpressionEditor";
 import { CqlBuilderLookup } from "../../../model/CqlBuilderLookup";
+import { getNewExpressionsAndLines } from "../../common/utils";
 
 export interface Definition {
   definitionName?: string;
@@ -29,16 +30,6 @@ export interface DefinitionProps {
   onClose?: Function;
 }
 
-export const formatExpressionName = (values) => {
-  return values?.type !== "Timing" && values?.type !== "Pre-Defined Functions"
-    ? values?.type === "Functions" || values?.type === "Fluent Functions"
-      ? values?.name?.replace(/([\w\s]+)\(\)/g, '"$1"()')
-      : values?.name.includes(".")
-      ? values?.name.replace(/(.*\.)(.*)/, '$1"$2"')
-      : `"${values?.name}"`
-    : values?.name;
-};
-
 export default function DefinitionBuilder({
   canEdit,
   handleApplyDefinition,
@@ -56,58 +47,6 @@ export default function DefinitionBuilder({
   );
   const [cursorPosition, setCursorPosition] = useState(null);
   const [autoInsert, setAutoInsert] = useState(false);
-
-  const handleExpressionEditorInsert = (values) => {
-    const formattedExpression = formatExpressionName(values);
-    let editorExpressionValue = expressionEditorValue;
-    let newCursorPosition = cursorPosition;
-
-    if (cursorPosition && !autoInsert) {
-      // Insert at cursor position
-      const { row, column } = cursorPosition;
-      const lines = expressionEditorValue.split("\n");
-      const currentLine = lines[row];
-      lines[row] =
-        currentLine.slice(0, column) +
-        formattedExpression +
-        currentLine.slice(column);
-      editorExpressionValue = lines.join("\n");
-      newCursorPosition = {
-        row,
-        column: column + formattedExpression.length,
-      } as unknown;
-    } else {
-      // Append to a new line
-      const lines = editorExpressionValue.split("\n");
-      const newLineIndex = lines.length;
-      editorExpressionValue +=
-        (editorExpressionValue ? "\n" : "") + formattedExpression;
-      newCursorPosition = {
-        row: newLineIndex,
-        column: formattedExpression.length,
-      };
-    }
-
-    setExpressionEditorValue(editorExpressionValue);
-    formik.setFieldValue("type", "");
-    formik.setFieldValue("name", "");
-
-    textAreaRef.current.editor.setValue(editorExpressionValue, 1);
-
-    // set the cursor to the end of the inserted text
-    textAreaRef.current.editor.moveCursorTo(
-      newCursorPosition.row,
-      newCursorPosition.column
-    );
-    textAreaRef.current.editor.clearSelection();
-
-    // set autoInsert to true for next insertion
-    setAutoInsert(true);
-
-    // clear cursor position to allow the next item to auto-insert at the end
-    setCursorPosition(null);
-  };
-
   const formik = useFormik({
     initialValues: {
       definitionName: definition?.definitionName || "",
@@ -118,9 +57,33 @@ export default function DefinitionBuilder({
     validationSchema: DefinitionSectionSchemaValidator,
     enableReinitialize: true,
     onSubmit: (values) => {
-      handleExpressionEditorInsert(values);
+      const newValues = getNewExpressionsAndLines(
+        values,
+        cursorPosition,
+        expressionEditorValue,
+        autoInsert
+      );
+      updateExpressionAndLines(newValues[0], newValues[1]);
     },
   });
+
+  // update formik, and expressionEditor, cursor, lines
+  const updateExpressionAndLines = (
+    newEditorExpressionValue,
+    newCursorPosition
+  ) => {
+    setExpressionEditorValue(newEditorExpressionValue);
+    formik.setFieldValue("type", "");
+    formik.setFieldValue("name", "");
+    textAreaRef.current.editor.setValue(newEditorExpressionValue, 1);
+    textAreaRef.current.editor.moveCursorTo(
+      newCursorPosition.row,
+      newCursorPosition.column
+    );
+    textAreaRef.current.editor.clearSelection();
+    setAutoInsert(true);
+    setCursorPosition(null);
+  };
   const { resetForm } = formik;
 
   useEffect(() => {
diff --git a/src/CqlBuilderPanel/definitionsSection/expressionSection/ExpressionEditor.tsx b/src/CqlBuilderPanel/definitionsSection/expressionSection/ExpressionEditor.tsx
index 54d19a34..c841a795 100644
--- a/src/CqlBuilderPanel/definitionsSection/expressionSection/ExpressionEditor.tsx
+++ b/src/CqlBuilderPanel/definitionsSection/expressionSection/ExpressionEditor.tsx
@@ -33,6 +33,15 @@ interface ExpressionsProps {
   setAutoInsert: Function;
 }
 
+export const availableTypes = [
+  "Parameters",
+  "Definitions",
+  "Functions",
+  "Fluent Functions",
+  "Timing",
+  "Pre-Defined Functions",
+];
+
 export default function ExpressionEditor(props: ExpressionsProps) {
   const {
     canEdit,
@@ -45,14 +54,6 @@ export default function ExpressionEditor(props: ExpressionsProps) {
     setAutoInsert,
   } = props;
   const [namesOptions, setNamesOptions] = useState([]);
-  const availableTypes = [
-    "Parameters",
-    "Definitions",
-    "Functions",
-    "Fluent Functions",
-    "Timing",
-    "Pre-Defined Functions",
-  ];
   const [editorHeight, setEditorHeight] = useState("100px");
   const formik: any = useFormikContext();
 
@@ -95,7 +96,14 @@ export default function ExpressionEditor(props: ExpressionsProps) {
   useEffect(() => {
     if (textAreaRef.current) {
       const lineCount = textAreaRef.current.editor.session.getLength();
-      const newHeight = Math.max(lineCount * 20, 100) + "px";
+      // newNeight should not exceed 180
+      /*
+      Text entry control (with line numbers, but only starting with 1 line, expandable as more text is added to it, max height is 11 lines and then it scrolls)
+      https://jira.cms.gov/browse/MAT-7792
+      */
+      const maxHeight = 180;
+      const proposedNewHeight = Math.max(lineCount * 20, 100);
+      const newHeight = Math.min(maxHeight, proposedNewHeight) + "px";
       setEditorHeight(newHeight);
     }
   }, [expressionEditorValue]);
diff --git a/src/CqlBuilderPanel/functionsSection/FunctionsSection.tsx b/src/CqlBuilderPanel/functionsSection/FunctionsSection.tsx
index 602df0f3..995a428b 100644
--- a/src/CqlBuilderPanel/functionsSection/FunctionsSection.tsx
+++ b/src/CqlBuilderPanel/functionsSection/FunctionsSection.tsx
@@ -84,6 +84,7 @@ export default function FunctionsSection({
           <FunctionBuilder
             canEdit={canEdit}
             handleApplyFunction={handleApplyFunction}
+            cqlBuilderLookupsTypes={cqlBuilderLookupsTypes}
           />
         )}
         {activeTab === "saved-functions" && (
diff --git a/src/CqlBuilderPanel/functionsSection/argumentSection/ArgumentSection.tsx b/src/CqlBuilderPanel/functionsSection/argumentSection/ArgumentSection.tsx
index 04bedf46..f084adf3 100644
--- a/src/CqlBuilderPanel/functionsSection/argumentSection/ArgumentSection.tsx
+++ b/src/CqlBuilderPanel/functionsSection/argumentSection/ArgumentSection.tsx
@@ -95,11 +95,11 @@ export default function ArgumentSection(props: ArgumentsProps) {
         <div tw="flex-grow pl-5">
           <Select
             label="Available DataTypes"
-            id="type-selector"
+            id="arg-type-selector"
             inputProps={{
-              "data-testid": "type-selector-input",
+              "data-testid": "arg-type-selector-input",
             }}
-            data-testid="type-selector"
+            data-testid="arg-type-selector"
             SelectDisplayProps={{
               "aria-required": "true",
             }}
diff --git a/src/CqlBuilderPanel/functionsSection/functionBuilder/FunctionBuilder.test.tsx b/src/CqlBuilderPanel/functionsSection/functionBuilder/FunctionBuilder.test.tsx
index 01cdcb5a..4adadfca 100644
--- a/src/CqlBuilderPanel/functionsSection/functionBuilder/FunctionBuilder.test.tsx
+++ b/src/CqlBuilderPanel/functionsSection/functionBuilder/FunctionBuilder.test.tsx
@@ -10,6 +10,8 @@ import { describe, it } from "@jest/globals";
 import "@testing-library/jest-dom";
 import FunctionBuilder from "./FunctionBuilder";
 import userEvent from "@testing-library/user-event";
+import { cqlBuilderLookup } from "../../__mocks__/MockCqlBuilderLookupsTypes";
+import { getNewExpressionsAndLines } from "../../common/utils";
 
 describe("CQL Function Builder Tests", () => {
   it("Should display name and comment fields", async () => {
@@ -295,4 +297,441 @@ describe("CQL Function Builder Tests", () => {
       "No Results were found"
     );
   });
+  it("Should open expression editor content on entry.", async () => {
+    render(
+      <FunctionBuilder
+        canEdit={true}
+        handleApplyFunction={jest.fn()}
+        cqlBuilderLookupsTypes={cqlBuilderLookup}
+      />
+    );
+    const functionNameInput = (await screen.findByTestId(
+      "function-name-text-input"
+    )) as HTMLInputElement;
+    expect(functionNameInput).toBeInTheDocument();
+    expect(functionNameInput.value).toBe("");
+    fireEvent.change(functionNameInput, {
+      target: { value: "IP" },
+    });
+    expect(functionNameInput.value).toBe("IP");
+
+    const definitionCommentTextBox = await screen.findByRole("textbox", {
+      name: "Comment",
+    });
+    expect(definitionCommentTextBox).toBeInTheDocument();
+
+    expect(
+      screen.getByTestId("terminology-section-Expression Editor-sub-heading")
+    ).toBeInTheDocument();
+    const typeInput = screen.getByTestId(
+      "type-selector-input"
+    ) as HTMLInputElement;
+    expect(typeInput).toBeInTheDocument();
+    expect(typeInput.value).toBe("");
+
+    fireEvent.change(typeInput, {
+      target: { value: "Timing" },
+    });
+    expect(typeInput.value).toBe("Timing");
+
+    const nameAutoComplete = screen.getByTestId("name-selector");
+    expect(nameAutoComplete).toBeInTheDocument();
+    const nameComboBox = within(nameAutoComplete).getByRole("combobox");
+    //name dropdown is populated with values based on type
+    await waitFor(() => expect(nameComboBox).toBeEnabled());
+
+    const nameDropDown = await screen.findByTestId("name-selector");
+    fireEvent.keyDown(nameDropDown, { key: "ArrowDown" });
+
+    const nameOptions = await screen.findAllByRole("option");
+    expect(nameOptions).toHaveLength(70);
+
+    const insertBtn = screen.getByTestId("expression-insert-btn");
+    expect(insertBtn).toBeInTheDocument();
+    expect(insertBtn).toBeDisabled();
+
+    fireEvent.click(nameOptions[0]);
+    expect(insertBtn).toBeEnabled();
+
+    const applyBtn = screen.getByTestId("function-apply-btn");
+    expect(applyBtn).toBeInTheDocument();
+    expect(applyBtn).toBeEnabled();
+  });
+
+  it("expression is inserted into text area when insert button is clicked", async () => {
+    render(
+      <FunctionBuilder
+        canEdit={true}
+        handleApplyFunction={jest.fn()}
+        cqlBuilderLookupsTypes={cqlBuilderLookup}
+      />
+    );
+    const functionNameInput = (await screen.findByTestId(
+      "function-name-text-input"
+    )) as HTMLInputElement;
+    expect(functionNameInput).toBeInTheDocument();
+    expect(functionNameInput.value).toBe("");
+    fireEvent.change(functionNameInput, {
+      target: { value: "IP" },
+    });
+    expect(functionNameInput.value).toBe("IP");
+
+    const definitionCommentTextBox = await screen.findByRole("textbox", {
+      name: "Comment",
+    });
+    expect(definitionCommentTextBox).toBeInTheDocument();
+    const definitionCommentInput = (await screen.findByTestId(
+      "function-comment-text"
+    )) as HTMLInputElement;
+    expect(definitionCommentInput.value).toBe("");
+    fireEvent.change(definitionCommentInput, {
+      target: { value: "comment" },
+    });
+    expect(definitionCommentInput.value).toBe("comment");
+
+    expect(
+      screen.getByTestId("terminology-section-Expression Editor-sub-heading")
+    ).toBeInTheDocument();
+    const typeInput = screen.getByTestId(
+      "type-selector-input"
+    ) as HTMLInputElement;
+    expect(typeInput).toBeInTheDocument();
+    expect(typeInput.value).toBe("");
+
+    fireEvent.change(typeInput, {
+      target: { value: "Timing" },
+    });
+    expect(typeInput.value).toBe("Timing");
+
+    const nameAutoComplete = screen.getByTestId("name-selector");
+    expect(nameAutoComplete).toBeInTheDocument();
+    const nameComboBox = within(nameAutoComplete).getByRole("combobox");
+    //name dropdown is populated with values based on type
+    await waitFor(() => expect(nameComboBox).toBeEnabled());
+
+    const nameDropDown = await screen.findByTestId("name-selector");
+    fireEvent.keyDown(nameDropDown, { key: "ArrowDown" });
+
+    const nameOptions = await screen.findAllByRole("option");
+    expect(nameOptions).toHaveLength(70);
+    const insertBtn = screen.getByTestId("expression-insert-btn");
+
+    expect(insertBtn).toBeInTheDocument();
+    expect(insertBtn).toBeDisabled();
+
+    fireEvent.click(nameOptions[0]);
+    expect(insertBtn).toBeEnabled();
+
+    fireEvent.click(insertBtn);
+    const definitionName = (await screen.findByTestId(
+      "function-name-text-input"
+    )) as HTMLInputElement;
+    expect(definitionName.value).toBe("IP");
+  });
+
+  it("should call handleApplyFunction with a function that we've created through the UI when other is selected.", async () => {
+    const handleApplyFn = jest.fn();
+    render(
+      <FunctionBuilder
+        canEdit={true}
+        handleApplyFunction={handleApplyFn}
+        cqlBuilderLookupsTypes={cqlBuilderLookup}
+      />
+    );
+    // name, insert, except args
+    const functionNameInput = (await screen.findByTestId(
+      "function-name-text-input"
+    )) as HTMLInputElement;
+    const argumentsSection = screen.getByTestId(
+      "terminology-section-Arguments-sub-heading"
+    );
+    expect(functionNameInput).toBeInTheDocument();
+    expect(functionNameInput.value).toBe("");
+    fireEvent.change(functionNameInput, {
+      target: { value: "IP" },
+    });
+    expect(functionNameInput.value).toBe("IP");
+
+    const definitionCommentTextBox = await screen.findByRole("textbox", {
+      name: "Comment",
+    });
+    expect(definitionCommentTextBox).toBeInTheDocument();
+    const definitionCommentInput = (await screen.findByTestId(
+      "function-comment-text"
+    )) as HTMLInputElement;
+    expect(definitionCommentInput.value).toBe("");
+    fireEvent.change(definitionCommentInput, {
+      target: { value: "comment" },
+    });
+    expect(definitionCommentInput.value).toBe("comment");
+
+    expect(
+      screen.getByTestId("terminology-section-Expression Editor-sub-heading")
+    ).toBeInTheDocument();
+    const typeInput = screen.getByTestId(
+      "type-selector-input"
+    ) as HTMLInputElement;
+    expect(typeInput).toBeInTheDocument();
+    expect(typeInput.value).toBe("");
+
+    fireEvent.change(typeInput, {
+      target: { value: "Timing" },
+    });
+    expect(typeInput.value).toBe("Timing");
+
+    const nameAutoComplete = screen.getByTestId("name-selector");
+    expect(nameAutoComplete).toBeInTheDocument();
+    const nameComboBox = within(nameAutoComplete).getByRole("combobox");
+    //name dropdown is populated with values based on type
+    await waitFor(() => expect(nameComboBox).toBeEnabled());
+
+    const nameDropDown = await screen.findByTestId("name-selector");
+    fireEvent.keyDown(nameDropDown, { key: "ArrowDown" });
+
+    const nameOptions = await screen.findAllByRole("option");
+    expect(nameOptions).toHaveLength(70);
+    const insertBtn = screen.getByTestId("expression-insert-btn");
+
+    expect(insertBtn).toBeInTheDocument();
+    expect(insertBtn).toBeDisabled();
+
+    fireEvent.click(nameOptions[0]);
+    expect(insertBtn).toBeEnabled();
+
+    fireEvent.click(insertBtn);
+    const definitionName = (await screen.findByTestId(
+      "function-name-text-input"
+    )) as HTMLInputElement;
+    expect(definitionName.value).toBe("IP");
+    // args
+    const argumentSectionButton = await within(argumentsSection).findByRole(
+      "button"
+    );
+    fireEvent.click(argumentSectionButton);
+
+    const argumentNameInput = (await screen.findByTestId(
+      "argument-name-input"
+    )) as HTMLInputElement;
+    expect(argumentNameInput).toBeInTheDocument();
+    expect(argumentNameInput.value).toBe("");
+    fireEvent.change(argumentNameInput, {
+      target: { value: "Test" },
+    });
+    expect(argumentNameInput.value).toBe("Test");
+
+    const dataTypeDropdown = await screen.findByTestId(
+      "arg-type-selector-input"
+    );
+    fireEvent.change(dataTypeDropdown, {
+      target: { value: "Other" },
+    });
+
+    // we now need to populate other textfield
+    const otherNameInput = (await screen.findByTestId(
+      "other-type-input"
+    )) as HTMLInputElement;
+    expect(otherNameInput).toBeInTheDocument();
+    expect(otherNameInput.value).toBe("");
+    fireEvent.change(otherNameInput, {
+      target: { value: "Other" },
+    });
+    expect(otherNameInput.value).toBe("Other");
+
+    const addButton = screen.getByTestId("function-argument-add-btn");
+    expect(addButton).toBeInTheDocument();
+    expect(addButton).toBeEnabled();
+
+    fireEvent.click(addButton);
+
+    const functionArgumentTable = screen.getByTestId("function-argument-tbl");
+    expect(functionArgumentTable).toBeInTheDocument();
+    const tableRow = functionArgumentTable.querySelector("tbody").children[0];
+    expect(tableRow.children[1].textContent).toEqual("Test");
+    // submit
+    const submitButton = screen.getByTestId("function-apply-btn");
+    expect(submitButton).toBeEnabled();
+    fireEvent.click(submitButton);
+
+    await waitFor(() => {
+      expect(handleApplyFn).toHaveBeenCalledWith(
+        expect.objectContaining({
+          comment: "comment",
+          expressionValue: "after",
+          fluentFunction: true,
+          functionName: "IP",
+          functionsArguments: [
+            expect.objectContaining({
+              argumentName: "Test",
+              dataType: "Other",
+            }),
+          ],
+        })
+      );
+    });
+  });
+  it("should call handleApplyFunction with a function that we've created through the UI", async () => {
+    const handleApplyFn = jest.fn();
+    render(
+      <FunctionBuilder
+        canEdit={true}
+        handleApplyFunction={handleApplyFn}
+        cqlBuilderLookupsTypes={cqlBuilderLookup}
+      />
+    );
+    // name, insert, except args
+    const functionNameInput = (await screen.findByTestId(
+      "function-name-text-input"
+    )) as HTMLInputElement;
+    const argumentsSection = screen.getByTestId(
+      "terminology-section-Arguments-sub-heading"
+    );
+    expect(functionNameInput).toBeInTheDocument();
+    expect(functionNameInput.value).toBe("");
+    fireEvent.change(functionNameInput, {
+      target: { value: "IP" },
+    });
+    expect(functionNameInput.value).toBe("IP");
+
+    const definitionCommentTextBox = await screen.findByRole("textbox", {
+      name: "Comment",
+    });
+    expect(definitionCommentTextBox).toBeInTheDocument();
+    const definitionCommentInput = (await screen.findByTestId(
+      "function-comment-text"
+    )) as HTMLInputElement;
+    expect(definitionCommentInput.value).toBe("");
+    fireEvent.change(definitionCommentInput, {
+      target: { value: "comment" },
+    });
+    expect(definitionCommentInput.value).toBe("comment");
+
+    expect(
+      screen.getByTestId("terminology-section-Expression Editor-sub-heading")
+    ).toBeInTheDocument();
+    const typeInput = screen.getByTestId(
+      "type-selector-input"
+    ) as HTMLInputElement;
+    expect(typeInput).toBeInTheDocument();
+    expect(typeInput.value).toBe("");
+
+    fireEvent.change(typeInput, {
+      target: { value: "Timing" },
+    });
+    expect(typeInput.value).toBe("Timing");
+
+    const nameAutoComplete = screen.getByTestId("name-selector");
+    expect(nameAutoComplete).toBeInTheDocument();
+    const nameComboBox = within(nameAutoComplete).getByRole("combobox");
+    //name dropdown is populated with values based on type
+    await waitFor(() => expect(nameComboBox).toBeEnabled());
+
+    const nameDropDown = await screen.findByTestId("name-selector");
+    fireEvent.keyDown(nameDropDown, { key: "ArrowDown" });
+
+    const nameOptions = await screen.findAllByRole("option");
+    expect(nameOptions).toHaveLength(70);
+    const insertBtn = screen.getByTestId("expression-insert-btn");
+
+    expect(insertBtn).toBeInTheDocument();
+    expect(insertBtn).toBeDisabled();
+
+    fireEvent.click(nameOptions[0]);
+    expect(insertBtn).toBeEnabled();
+
+    fireEvent.click(insertBtn);
+    const definitionName = (await screen.findByTestId(
+      "function-name-text-input"
+    )) as HTMLInputElement;
+    expect(definitionName.value).toBe("IP");
+    // args
+    const argumentSectionButton = await within(argumentsSection).findByRole(
+      "button"
+    );
+    fireEvent.click(argumentSectionButton);
+
+    const argumentNameInput = (await screen.findByTestId(
+      "argument-name-input"
+    )) as HTMLInputElement;
+    expect(argumentNameInput).toBeInTheDocument();
+    expect(argumentNameInput.value).toBe("");
+    fireEvent.change(argumentNameInput, {
+      target: { value: "Test" },
+    });
+    expect(argumentNameInput.value).toBe("Test");
+
+    const dataTypeDropdown = await screen.findByTestId(
+      "arg-type-selector-input"
+    );
+    fireEvent.change(dataTypeDropdown, {
+      target: { value: "Boolean" },
+    });
+
+    const addButton = screen.getByTestId("function-argument-add-btn");
+    expect(addButton).toBeInTheDocument();
+    expect(addButton).toBeEnabled();
+    // get available dataTypes 0
+
+    fireEvent.click(addButton);
+
+    const functionArgumentTable = screen.getByTestId("function-argument-tbl");
+    expect(functionArgumentTable).toBeInTheDocument();
+    const tableRow = functionArgumentTable.querySelector("tbody").children[0];
+    expect(tableRow.children[1].textContent).toEqual("Test");
+    // submit
+    const submitButton = screen.getByTestId("function-apply-btn");
+    expect(submitButton).toBeEnabled();
+    fireEvent.click(submitButton);
+
+    await waitFor(() => {
+      expect(handleApplyFn).toHaveBeenCalledWith(
+        expect.objectContaining({
+          comment: "comment",
+          expressionValue: "after",
+          fluentFunction: true,
+          functionName: "IP",
+          functionsArguments: [
+            expect.objectContaining({
+              argumentName: "Test",
+              dataType: "Boolean",
+            }),
+          ],
+        })
+      );
+    });
+  });
+});
+
+describe("getNewExpressionsAndLines", () => {
+  it("should insert the formatted expression at the cursor position when cursorPosition is provided and autoInsert is false", () => {
+    const values = { name: "test", type: "Functions" };
+    const cursorPosition = { row: 1, column: 5 };
+    const expressionEditorValue = "Line 1\ntesttesttest2 content\nLine 3";
+    const autoInsert = false;
+    const result = getNewExpressionsAndLines(
+      values,
+      cursorPosition,
+      expressionEditorValue,
+      autoInsert
+    );
+
+    expect(result[0]).toBe("Line 1\ntestttestesttest2 content\nLine 3");
+    expect(result[1]).toEqual({ row: 1, column: 9 });
+  });
+
+  it("should append the formatted expression to a new line when cursorPosition is not provided or autoInsert is true", () => {
+    const values = { name: "test", type: "Functions" };
+    const cursorPosition = null;
+    const expressionEditorValue = "Line 1\nLine 2 content\nLine 3";
+    const autoInsert = true;
+
+    const result = getNewExpressionsAndLines(
+      values,
+      cursorPosition,
+      expressionEditorValue,
+      autoInsert
+    );
+
+    expect(result[0]).toBe("Line 1\nLine 2 content\nLine 3\ntest");
+    expect(result[1]).toEqual({ row: 3, column: 4 });
+  });
 });
diff --git a/src/CqlBuilderPanel/functionsSection/functionBuilder/FunctionBuilder.tsx b/src/CqlBuilderPanel/functionsSection/functionBuilder/FunctionBuilder.tsx
index 0409ab08..b8c5c2ec 100644
--- a/src/CqlBuilderPanel/functionsSection/functionBuilder/FunctionBuilder.tsx
+++ b/src/CqlBuilderPanel/functionsSection/functionBuilder/FunctionBuilder.tsx
@@ -14,6 +14,9 @@ import { Checkbox, FormControlLabel } from "@mui/material";
 import { Box } from "@mui/system";
 import ConfirmationDialog from "../../common/ConfirmationDialog";
 import ArgumentSection from "../argumentSection/ArgumentSection";
+import ExpressionEditor from "../../definitionsSection/expressionSection/ExpressionEditor";
+import { getNewExpressionsAndLines } from "../../common/utils";
+import { CqlBuilderLookup } from "../../../model/CqlBuilderLookup";
 
 export interface Funct {
   functionName?: string;
@@ -23,11 +26,13 @@ export interface Funct {
 }
 
 export interface FunctionProps {
+  cqlBuilderLookupsTypes: CqlBuilderLookup;
   canEdit: boolean;
   handleApplyFunction: Function;
   handleFunctionEdit?: Function;
   funct?: Funct;
   onClose?: Function;
+  operation?: string;
 }
 
 export default function FunctionBuilder({
@@ -36,6 +41,8 @@ export default function FunctionBuilder({
   handleFunctionEdit,
   onClose,
   funct,
+  cqlBuilderLookupsTypes,
+  operation,
 }: FunctionProps) {
   const [argumentsEditorOpen, setArgumentsEditorOpen] =
     useState<boolean>(false);
@@ -44,19 +51,51 @@ export default function FunctionBuilder({
   const textAreaRef = useRef(null);
   const [confirmationDialog, setConfirmationDialog] = useState<boolean>(false);
 
+  const [expressionEditorValue, setExpressionEditorValue] = useState("");
+  const [cursorPosition, setCursorPosition] = useState(null);
+  const [autoInsert, setAutoInsert] = useState(false);
   const formik = useFormik({
     initialValues: {
       functionName: funct?.functionName || "",
       comment: funct?.comment || "",
       fluentFunction: funct?.fluentFunction || true,
       functionsArguments: funct?.functionsArguments || [],
+      type: "",
+      name: "",
     },
     validationSchema: FunctionSectionSchemaValidator,
     enableReinitialize: true,
-    onSubmit: (values) => {},
+    onSubmit: (values) => {
+      const newValues = getNewExpressionsAndLines(
+        values,
+        cursorPosition,
+        expressionEditorValue,
+        autoInsert
+      );
+      updateExpressionAndLines(newValues[0], newValues[1]);
+    },
   });
   const { resetForm } = formik;
 
+  // update formik, and expressionEditor, cursor, lines
+  const updateExpressionAndLines = (
+    newEditorExpressionValue,
+    newCursorPosition
+  ) => {
+    setExpressionEditorValue(newEditorExpressionValue);
+    formik.setFieldValue("type", "");
+    formik.setFieldValue("name", "");
+
+    textAreaRef.current.editor.setValue(newEditorExpressionValue, 1);
+    textAreaRef.current.editor.moveCursorTo(
+      newCursorPosition.row,
+      newCursorPosition.column
+    );
+    textAreaRef.current.editor.clearSelection();
+    setAutoInsert(true);
+    setCursorPosition(null);
+  };
+
   const addArgumentToFunctionsArguments = (fn) => {
     const newArgs = [...formik.values.functionsArguments, fn];
     formik.setFieldValue("functionsArguments", newArgs);
@@ -91,6 +130,12 @@ export default function FunctionBuilder({
               error={Boolean(formik.errors.functionName)}
               helperText={formik.errors.functionName}
               {...formik.getFieldProps("functionName")}
+              onChange={(e) => {
+                formik.handleChange(e);
+                if (e.target.value && !expressionEditorOpen) {
+                  setExpressionEditorOpen(true);
+                }
+              }}
             />
           </div>
           <Box sx={{ marginTop: "22px" }}>
@@ -143,11 +188,18 @@ export default function FunctionBuilder({
         </ExpandingSection>
 
         <div style={{ marginTop: "36px" }} />
-        <ExpandingSection
-          title="Expression Editor"
-          showHeaderContent={expressionEditorOpen}
-          children={<></>}
-        />
+        <FormikProvider value={formik}>
+          <ExpressionEditor
+            canEdit={canEdit}
+            expressionEditorOpen={expressionEditorOpen}
+            cqlBuilderLookupsTypes={cqlBuilderLookupsTypes}
+            textAreaRef={textAreaRef}
+            expressionEditorValue={expressionEditorValue}
+            setExpressionEditorValue={setExpressionEditorValue}
+            setCursorPosition={setCursorPosition}
+            setAutoInsert={setAutoInsert}
+          />
+        </FormikProvider>
         <div className="form-actions">
           <Button
             id="clear-function-btn"
@@ -164,8 +216,18 @@ export default function FunctionBuilder({
           <Button
             data-testid={`function-apply-btn`}
             disabled={!formik.values.functionName || !canEdit || !formik.dirty}
-            // tw="ml-4"
-            onClick={() => {}}
+            onClick={() => {
+              const functionToApply = {
+                functionName: formik.values.functionName,
+                comment: formik.values.comment,
+                functionsArguments: formik.values.functionsArguments,
+                fluentFunction: formik.values.fluentFunction,
+                expressionValue: expressionEditorValue,
+              };
+              resetForm();
+              setExpressionEditorValue("");
+              handleApplyFunction(functionToApply);
+            }}
           >
             Apply
           </Button>
diff --git a/src/cqlEditorWithTerminology/CqlEditorWithTerminology.scss b/src/cqlEditorWithTerminology/CqlEditorWithTerminology.scss
index 6c1096e6..2f9ed167 100644
--- a/src/cqlEditorWithTerminology/CqlEditorWithTerminology.scss
+++ b/src/cqlEditorWithTerminology/CqlEditorWithTerminology.scss
@@ -62,6 +62,9 @@
         > .MuiTabs-root {
           background-color: #ededed;
           margin-left: 16px;
+          > .MuiTabs-scroller {
+            overflow: auto !important;
+          }
         }
       }
       > .panel-content {