diff --git a/docker-compose-dev.yaml b/docker-compose-dev.yaml
index c3038c99..7ef9d7bf 100644
--- a/docker-compose-dev.yaml
+++ b/docker-compose-dev.yaml
@@ -309,7 +309,7 @@ services:
       - DOMINO_DB_HOST=domino_postgres
       - DOMINO_DB_PORT=5432
       - DOMINO_DB_NAME=postgres
-      - DOMINO_DEFAULT_PIECES_REPOSITORY_VERSION=0.4.2
+      - DOMINO_DEFAULT_PIECES_REPOSITORY_VERSION=0.4.3
       - DOMINO_DEFAULT_PIECES_REPOSITORY_TOKEN=${DOMINO_DEFAULT_PIECES_REPOSITORY_TOKEN}
       - DOMINO_GITHUB_ACCESS_TOKEN_WORKFLOWS=${DOMINO_GITHUB_ACCESS_TOKEN_WORKFLOWS}
       - DOMINO_GITHUB_WORKFLOWS_REPOSITORY=${DOMINO_GITHUB_WORKFLOWS_REPOSITORY}
diff --git a/frontend/src/components/CodeEditorInput/index.tsx b/frontend/src/components/CodeEditorInput/index.tsx
index d787245d..e7f6cb20 100644
--- a/frontend/src/components/CodeEditorInput/index.tsx
+++ b/frontend/src/components/CodeEditorInput/index.tsx
@@ -7,11 +7,16 @@ import {
   useFormContext,
 } from "react-hook-form";
 
-const CodeEditorItem = React.forwardRef<HTMLTextAreaElement>(
-  ({ ...register }, ref) => (
+interface Props {
+  language?: string;
+  placeholder?: string;
+}
+
+const CodeEditorItem = React.forwardRef<HTMLTextAreaElement, Props>(
+  ({ language = "python", placeholder, ...register }, ref) => (
     <CodeEditor
-      language="python"
-      placeholder="Enter Python code."
+      language={language}
+      placeholder={placeholder ?? ""}
       padding={15}
       style={{
         fontSize: 12,
@@ -33,18 +38,30 @@ const CodeEditorItem = React.forwardRef<HTMLTextAreaElement>(
 
 CodeEditorItem.displayName = "CodeEditorItem";
 
-interface Props<T> {
+interface CodeEditorInputProps<T> {
   name: Path<T>;
+  language?: string;
+  placeholder?: string;
 }
 
-function CodeEditorInput<T extends FieldValues>({ name }: Props<T>) {
+function CodeEditorInput<T extends FieldValues>({
+  name,
+  language,
+  placeholder,
+}: CodeEditorInputProps<T>) {
   const { control } = useFormContext();
 
   return (
     <Controller
       name={name}
       control={control}
-      render={({ field }) => <CodeEditorItem {...field} />}
+      render={({ field }) => (
+        <CodeEditorItem
+          language={language}
+          placeholder={placeholder}
+          {...field}
+        />
+      )}
     />
   );
 }
diff --git a/frontend/src/components/Modal/index.tsx b/frontend/src/components/Modal/index.tsx
new file mode 100644
index 00000000..56e938f8
--- /dev/null
+++ b/frontend/src/components/Modal/index.tsx
@@ -0,0 +1,81 @@
+import {
+  Button,
+  Dialog,
+  DialogActions,
+  DialogContent,
+  DialogContentText,
+  DialogTitle,
+  Grid,
+} from "@mui/material";
+import React, { useCallback, useImperativeHandle, useState } from "react";
+
+interface Props {
+  title: string;
+  content?: string | React.ReactNode;
+
+  confirmFn?: () => void;
+  cancelFn?: () => void;
+}
+
+export interface ModalRef {
+  open: () => void;
+  close: () => void;
+}
+
+export const Modal = React.forwardRef<ModalRef, Props>(
+  ({ cancelFn, confirmFn, title, content }, ref) => {
+    const [isOpen, setIsOpen] = useState(false);
+
+    const open = () => {
+      setIsOpen(true);
+    };
+
+    const handleClose = useCallback(() => {
+      if (cancelFn) {
+        cancelFn();
+      }
+
+      setIsOpen(false);
+    }, []);
+
+    const handleConfirm = useCallback(() => {
+      if (confirmFn) {
+        confirmFn();
+      }
+
+      setIsOpen(false);
+    }, []);
+
+    useImperativeHandle(ref, () => ({
+      open,
+      close: handleClose,
+    }));
+
+    return (
+      <Dialog open={isOpen} onClose={handleClose}>
+        <DialogTitle>{title}</DialogTitle>
+        <DialogContent>
+          <DialogContentText>{content}</DialogContentText>
+        </DialogContent>
+        <DialogActions>
+          <Grid container justifyContent="center" spacing={4}>
+            {cancelFn && (
+              <Grid item>
+                <Button onClick={handleClose} variant="contained">
+                  Cancel
+                </Button>
+              </Grid>
+            )}
+            <Grid item>
+              <Button onClick={handleConfirm} variant="contained">
+                OK
+              </Button>
+            </Grid>
+          </Grid>
+        </DialogActions>
+      </Dialog>
+    );
+  },
+);
+
+Modal.displayName = "Modal";
diff --git a/frontend/src/components/NewFeatureDialog/index.tsx b/frontend/src/components/NewFeatureDialog/index.tsx
deleted file mode 100644
index 449507f7..00000000
--- a/frontend/src/components/NewFeatureDialog/index.tsx
+++ /dev/null
@@ -1,43 +0,0 @@
-import {
-  Button,
-  Dialog,
-  DialogActions,
-  DialogContent,
-  DialogContentText,
-  DialogTitle,
-  Grid,
-} from "@mui/material";
-import React from "react";
-
-interface Props {
-  isOpen: boolean;
-  confirmFn: () => void;
-}
-
-export const NewFeatureDialog: React.FC<Props> = ({ isOpen, confirmFn }) => {
-  return (
-    <Dialog
-      open={isOpen}
-      onClose={confirmFn}
-      aria-labelledby="alert-dialog-title"
-      aria-describedby="alert-dialog-description"
-    >
-      <DialogTitle id="alert-dialog-title">New feature</DialogTitle>
-      <DialogContent>
-        <DialogContentText id="alert-dialog-description">
-          This feature is not ready yet! We launch new versions every time,
-          check out our changelog for more information !
-        </DialogContentText>
-      </DialogContent>
-      <DialogActions>
-        <Grid container justifyContent="center" spacing={4}>
-          <Grid item>
-            <Button onClick={confirmFn} variant="contained">
-              OK
-            </Button>
-          </Grid>
-        </Grid>
-      </DialogActions>
-    </Dialog>
-  );
-};
diff --git a/frontend/src/components/WorkflowPanel/DefaultNode/index.tsx b/frontend/src/components/WorkflowPanel/DefaultNode/index.tsx
index 6f351d66..e30c310a 100644
--- a/frontend/src/components/WorkflowPanel/DefaultNode/index.tsx
+++ b/frontend/src/components/WorkflowPanel/DefaultNode/index.tsx
@@ -71,7 +71,7 @@ export const CustomNode = memo<DefaultNodeProps>(({ id, data, selected }) => {
       ...data.style.nodeStyle,
       display: "flex",
       flexDirection: "row",
-      justifyContent: "center",
+      justifyContent: "space-evenly",
       alignItems: "center",
 
       position: "relative",
@@ -88,7 +88,7 @@ export const CustomNode = memo<DefaultNodeProps>(({ id, data, selected }) => {
         backgroundColor: theme.palette.error.light,
         color: theme.palette.error.contrastText,
       }),
-    };
+    } satisfies CSSProperties;
   }, [data, selected]);
 
   const { sourcePosition, targetPosition } = useMemo(
diff --git a/frontend/src/components/WorkflowPanel/RunNode/index.tsx b/frontend/src/components/WorkflowPanel/RunNode/index.tsx
index 6ee470b7..d3f844a4 100644
--- a/frontend/src/components/WorkflowPanel/RunNode/index.tsx
+++ b/frontend/src/components/WorkflowPanel/RunNode/index.tsx
@@ -88,7 +88,7 @@ const RunNode = memo<RunNodeProps>(({ id, data, selected }) => {
       ...data.style.nodeStyle,
       display: "flex",
       flexDirection: "row",
-      justifyContent: "center",
+      justifyContent: "space-evenly",
       alignItems: "center",
       textAlign: "center",
       position: "relative",
diff --git a/frontend/src/features/workflowEditor/components/SidebarForm/PieceForm/PieceFormItem/index.tsx b/frontend/src/features/workflowEditor/components/SidebarForm/PieceForm/PieceFormItem/index.tsx
index 618da339..e70f6105 100644
--- a/frontend/src/features/workflowEditor/components/SidebarForm/PieceForm/PieceFormItem/index.tsx
+++ b/frontend/src/features/workflowEditor/components/SidebarForm/PieceForm/PieceFormItem/index.tsx
@@ -155,10 +155,40 @@ const PieceFormItem: React.FC<PieceFormItemProps> = ({
     "type" in schema &&
     "widget" in schema &&
     schema.type === "string" &&
-    schema.widget === "codeeditor"
+    (schema.widget === "codeeditor" || schema.widget === "codeeditor-python")
   ) {
     inputElement = (
-      <CodeEditorInput<IWorkflowPieceData> name={`inputs.${itemKey}.value`} />
+      <CodeEditorInput<IWorkflowPieceData>
+        name={`inputs.${itemKey}.value`}
+        language="python"
+        placeholder="Enter Python code."
+      />
+    );
+  } else if (
+    "type" in schema &&
+    "widget" in schema &&
+    schema.type === "string" &&
+    schema.widget === "codeeditor-json"
+  ) {
+    inputElement = (
+      <CodeEditorInput<IWorkflowPieceData>
+        name={`inputs.${itemKey}.value`}
+        language="json"
+        placeholder="Enter JSON code."
+      />
+    );
+  } else if (
+    "type" in schema &&
+    "widget" in schema &&
+    schema.type === "string" &&
+    schema.widget === "codeeditor-sql"
+  ) {
+    inputElement = (
+      <CodeEditorInput<IWorkflowPieceData>
+        name={`inputs.${itemKey}.value`}
+        language="sql"
+        placeholder="Enter SQL code."
+      />
     );
   } else if (
     "type" in schema &&
diff --git a/frontend/src/features/workflowEditor/components/SidebarForm/index.tsx b/frontend/src/features/workflowEditor/components/SidebarForm/index.tsx
index 936a57f5..dae41c48 100644
--- a/frontend/src/features/workflowEditor/components/SidebarForm/index.tsx
+++ b/frontend/src/features/workflowEditor/components/SidebarForm/index.tsx
@@ -33,7 +33,7 @@ const SidebarPieceForm: React.FC<ISidebarPieceFormProps> = (props) => {
   const { schema, formId, open, onClose, title } = props;
 
   const {
-    setForageWorkflowPiecesData,
+    setForageWorkflowPiecesDataById,
     fetchForageWorkflowPiecesDataById,
     setForageWorkflowPiecesOutputSchema,
     clearDownstreamDataById,
@@ -141,10 +141,10 @@ const SidebarPieceForm: React.FC<ISidebarPieceFormProps> = (props) => {
 
   const saveData = useCallback(async () => {
     if (formId && open) {
-      await setForageWorkflowPiecesData(formId, data as IWorkflowPieceData);
+      await setForageWorkflowPiecesDataById(formId, data as IWorkflowPieceData);
       await updateOutputSchema();
     }
-  }, [formId, open, setForageWorkflowPiecesData, data, updateOutputSchema]);
+  }, [formId, open, setForageWorkflowPiecesDataById, data, updateOutputSchema]);
 
   // load forage
   useEffect(() => {
diff --git a/frontend/src/features/workflowEditor/components/SidebarSettingsForm/index.tsx b/frontend/src/features/workflowEditor/components/SidebarSettingsForm/index.tsx
index 1c6a29b5..093da384 100644
--- a/frontend/src/features/workflowEditor/components/SidebarSettingsForm/index.tsx
+++ b/frontend/src/features/workflowEditor/components/SidebarSettingsForm/index.tsx
@@ -15,7 +15,14 @@ import {
   storageSourcesAWS,
   storageSourcesLocal,
 } from "features/workflowEditor/context/types";
-import { useCallback, useEffect, useState } from "react";
+import {
+  useCallback,
+  useEffect,
+  useState,
+  forwardRef,
+  useImperativeHandle,
+  type ForwardedRef,
+} from "react";
 import { FormProvider, useForm } from "react-hook-form";
 import { yupResolver } from "utils";
 import * as yup from "yup";
@@ -100,181 +107,203 @@ export const WorkflowSettingsFormSchema: ValidationSchema = yup.object().shape({
   }),
 });
 
-const SidebarSettingsForm = (props: ISidebarSettingsFormProps) => {
-  const { open, onClose } = props;
+export interface SidebarSettingsFormRef {
+  loadData: () => Promise<void>;
+}
 
-  const { fetchWorkflowSettingsData, setWorkflowSettingsData } =
-    useWorkflowsEditor();
+const SidebarSettingsForm = forwardRef<
+  SidebarSettingsFormRef,
+  ISidebarSettingsFormProps
+>(
+  (
+    props: ISidebarSettingsFormProps,
+    ref: ForwardedRef<SidebarSettingsFormRef>,
+  ) => {
+    const { open, onClose } = props;
 
-  const resolver = yupResolver(WorkflowSettingsFormSchema);
-  const methods = useForm<IWorkflowSettings>({ mode: "onChange", resolver });
-  const { register, watch, reset, trigger, getValues } = methods;
-  const formData = watch();
+    const { fetchWorkflowSettingsData, setWorkflowSettingsData } =
+      useWorkflowsEditor();
 
-  const [loaded, setLoaded] = useState(false);
+    const resolver = yupResolver(WorkflowSettingsFormSchema);
+    const methods = useForm<IWorkflowSettings>({ mode: "onChange", resolver });
+    const { register, watch, reset, trigger, getValues } = methods;
+    const formData = watch();
 
-  const validate = useCallback(() => {
-    if (loaded) void trigger();
-  }, [loaded, trigger]);
+    const [loaded, setLoaded] = useState(false);
 
-  useEffect(() => {
-    validate();
-  }, [validate]);
+    const validate = useCallback(() => {
+      if (loaded) void trigger();
+    }, [loaded, trigger]);
 
-  const loadData = useCallback(async () => {
-    const data = await fetchWorkflowSettingsData();
-    if (Object.keys(data).length === 0) {
-      reset(defaultSettingsData);
-    } else {
-      reset(data);
-    }
-    setLoaded(true);
-  }, [reset, fetchWorkflowSettingsData]);
+    useEffect(() => {
+      validate();
+    }, [validate]);
 
-  const saveData = useCallback(async () => {
-    if (open) {
-      await setWorkflowSettingsData(formData);
-    }
-  }, [formData, open, setWorkflowSettingsData]);
+    const loadData = useCallback(async () => {
+      const data = await fetchWorkflowSettingsData();
+      if (Object.keys(data).length === 0) {
+        reset(defaultSettingsData);
+        await setWorkflowSettingsData(defaultSettingsData);
+      } else {
+        reset(data);
+      }
+      setLoaded(true);
+    }, [reset, fetchWorkflowSettingsData, setWorkflowSettingsData]);
+
+    const saveData = useCallback(async () => {
+      if (open) {
+        await setWorkflowSettingsData(formData);
+      }
+    }, [formData, open, setWorkflowSettingsData]);
 
-  useEffect(() => {
-    if (open) {
+    useEffect(() => {
       void loadData();
-    }
-  }, [open, loadData]);
+    }, [open, loadData]);
 
-  useEffect(() => {
-    void saveData();
-  }, [saveData]);
+    useEffect(() => {
+      void saveData();
+    }, [saveData]);
 
-  if (Object.keys(formData).length === 0) {
-    return null;
-  }
+    useImperativeHandle(
+      ref,
+      () => {
+        return {
+          loadData,
+        };
+      },
+      [loadData],
+    );
 
-  return (
-    <Drawer
-      anchor="left"
-      open={open}
-      onClose={onClose}
-      sx={{
-        "& .MuiDrawer-paper": {
-          marginTop: "4rem",
-          width: "33%",
-          maxWidth: "500px",
-          minWidth: "300px",
-        },
-      }}
-      BackdropProps={{ style: { backgroundColor: "transparent" } }}
-    >
-      <Grid container>
-        <Grid container padding={1}>
-          <Typography
-            variant="h5"
-            component="h5"
-            sx={{ marginTop: "20px", marginBottom: "20px" }}
-          >
-            Settings
-          </Typography>
-          <FormProvider {...methods}>
-            <Grid container spacing={2}>
-              <Grid item xs={12}>
-                <TextInput
-                  variant="outlined"
-                  name="config.name"
-                  label="Name"
-                  defaultValue={defaultSettingsData.config.name}
-                />
-              </Grid>
-              <Grid item xs={12}>
-                <SelectInput
-                  name="config.scheduleInterval"
-                  defaultValue={defaultSettingsData.config.scheduleInterval}
-                  options={Object.values(scheduleIntervals)}
-                  label="Schedule Interval"
-                />
-              </Grid>
-              <Grid item xs={12}>
-                <DatetimeInput
-                  name="config.startDate"
-                  label="Start Date/Time"
-                  type="date-time"
-                />
-              </Grid>
-              <Grid
-                container
-                spacing={2}
-                alignItems="center"
-                sx={{ margin: "0px" }}
-              >
-                <Grid item xs={4}>
-                  <SelectInput
-                    name="config.endDateType"
-                    label="End Date/Time"
-                    options={Object.values(endDateTypes)}
-                    defaultValue={defaultSettingsData.config.endDateType}
-                  />
-                </Grid>
-                {getValues().config.endDateType ===
-                  endDateTypes.UserDefined && (
-                  <Grid item xs={8}>
-                    <DatetimeInput
-                      name="config.endDate"
-                      label="End Date/Time"
-                      type="date-time"
-                    />
-                  </Grid>
-                )}
-              </Grid>
-            </Grid>
-          </FormProvider>
-        </Grid>
-        <Grid container padding={1}>
-          <Grid item xs={12}>
+    if (Object.keys(formData).length === 0) {
+      return null;
+    }
+
+    return (
+      <Drawer
+        anchor="left"
+        open={open}
+        onClose={onClose}
+        sx={{
+          "& .MuiDrawer-paper": {
+            marginTop: "4rem",
+            width: "33%",
+            maxWidth: "500px",
+            minWidth: "300px",
+          },
+        }}
+        BackdropProps={{ style: { backgroundColor: "transparent" } }}
+      >
+        <Grid container>
+          <Grid container padding={1}>
             <Typography
               variant="h5"
               component="h5"
               sx={{ marginTop: "20px", marginBottom: "20px" }}
             >
-              Storage
+              Settings
             </Typography>
-          </Grid>
-          <FormProvider {...methods}>
-            <Grid container spacing={2}>
-              <Grid item xs={12}>
-                <SelectInput
-                  label="Storage Source"
-                  name="storage.storageSource"
-                  options={storageSourceOptions}
-                  defaultValue={defaultSettingsData.storage.storageSource}
-                />
-              </Grid>
-              {formData.storage.storageSource === storageSourcesAWS.AWS_S3 ? (
-                <>
-                  <Grid item xs={12}>
-                    <TextField
-                      label="Bucket"
-                      defaultValue={defaultSettingsData.storage.bucket}
-                      required
-                      fullWidth
-                      {...register("storage.bucket")}
-                    />
-                  </Grid>
-                  <Grid item xs={12}>
-                    <TextField
-                      label="Base Folder"
-                      defaultValue={defaultSettingsData.storage.baseFolder}
-                      required
-                      fullWidth
-                      {...register("storage.baseFolder")}
+            <FormProvider {...methods}>
+              <Grid container spacing={2}>
+                <Grid item xs={12}>
+                  <TextInput
+                    variant="outlined"
+                    name="config.name"
+                    label="Name"
+                    defaultValue={defaultSettingsData.config.name}
+                  />
+                </Grid>
+                <Grid item xs={12}>
+                  <SelectInput
+                    name="config.scheduleInterval"
+                    defaultValue={defaultSettingsData.config.scheduleInterval}
+                    options={Object.values(scheduleIntervals)}
+                    label="Schedule"
+                  />
+                </Grid>
+                <Grid item xs={12}>
+                  <DatetimeInput
+                    name="config.startDate"
+                    label="Start Date/Time"
+                    type="date-time"
+                  />
+                </Grid>
+                <Grid
+                  container
+                  spacing={2}
+                  alignItems="center"
+                  sx={{ margin: "0px" }}
+                >
+                  <Grid item xs={4}>
+                    <SelectInput
+                      name="config.endDateType"
+                      label="End Date/Time"
+                      options={Object.values(endDateTypes)}
+                      defaultValue={defaultSettingsData.config.endDateType}
                     />
                   </Grid>
-                </>
-              ) : null}
+                  {getValues().config.endDateType ===
+                    endDateTypes.UserDefined && (
+                    <Grid item xs={8}>
+                      <DatetimeInput
+                        name="config.endDate"
+                        label="End Date/Time"
+                        type="date-time"
+                      />
+                    </Grid>
+                  )}
+                </Grid>
+              </Grid>
+            </FormProvider>
+          </Grid>
+          <Grid container padding={1}>
+            <Grid item xs={12}>
+              <Typography
+                variant="h5"
+                component="h5"
+                sx={{ marginTop: "20px", marginBottom: "20px" }}
+              >
+                Storage
+              </Typography>
             </Grid>
-          </FormProvider>
+            <FormProvider {...methods}>
+              <Grid container spacing={2}>
+                <Grid item xs={12}>
+                  <SelectInput
+                    label="Storage Source"
+                    name="storage.storageSource"
+                    options={storageSourceOptions}
+                    defaultValue={defaultSettingsData.storage.storageSource}
+                  />
+                </Grid>
+                {formData.storage.storageSource === storageSourcesAWS.AWS_S3 ? (
+                  <>
+                    <Grid item xs={12}>
+                      <TextField
+                        label="Bucket"
+                        defaultValue={defaultSettingsData.storage.bucket}
+                        required
+                        fullWidth
+                        {...register("storage.bucket")}
+                      />
+                    </Grid>
+                    <Grid item xs={12}>
+                      <TextField
+                        label="Base Folder"
+                        defaultValue={defaultSettingsData.storage.baseFolder}
+                        required
+                        fullWidth
+                        {...register("storage.baseFolder")}
+                      />
+                    </Grid>
+                  </>
+                ) : null}
+              </Grid>
+            </FormProvider>
+          </Grid>
         </Grid>
-      </Grid>
-    </Drawer>
-  );
-};
-export default SidebarSettingsForm;
+      </Drawer>
+    );
+  },
+);
+SidebarSettingsForm.displayName = "SidebarSettingsForm";
+export { SidebarSettingsForm };
diff --git a/frontend/src/features/workflowEditor/components/WorkflowEditor.tsx b/frontend/src/features/workflowEditor/components/WorkflowEditor.tsx
index 58c21f8e..b783d81e 100644
--- a/frontend/src/features/workflowEditor/components/WorkflowEditor.tsx
+++ b/frontend/src/features/workflowEditor/components/WorkflowEditor.tsx
@@ -1,10 +1,12 @@
 import { Settings as SettingsSuggestIcon } from "@mui/icons-material";
 import ClearIcon from "@mui/icons-material/Clear";
 import DownloadIcon from "@mui/icons-material/Download";
+import IosShareIcon from "@mui/icons-material/IosShare";
 import SaveIcon from "@mui/icons-material/Save";
-import { Button, Grid, Paper } from "@mui/material";
+import { Button, Grid, Paper, styled } from "@mui/material";
 import { AxiosError } from "axios";
 import Loading from "components/Loading";
+import { Modal, type ModalRef } from "components/Modal";
 import {
   type WorkflowPanelRef,
   WorkflowPanel,
@@ -15,11 +17,13 @@ import { useWorkflowsEditor } from "features/workflowEditor/context";
 import { type DragEvent, useCallback, useRef, useState } from "react";
 import { toast } from "react-toastify";
 import { type Edge, type Node, type XYPosition } from "reactflow";
-import { yupResolver, useInterval } from "utils";
+import localForage from "services/config/localForage.config";
+import { yupResolver, useInterval, exportToJson } from "utils";
 import { v4 as uuidv4 } from "uuid";
 import * as yup from "yup";
 
 import { type IWorkflowPieceData, storageAccessModes } from "../context/types";
+import { type DominoWorkflowForage } from "../context/workflowsEditor";
 import { containerResourcesSchema } from "../schemas/containerResourcesSchemas";
 import { extractDefaultInputValues, extractDefaultValues } from "../utils";
 
@@ -28,8 +32,10 @@ import SidebarPieceForm from "./SidebarForm";
 import { ContainerResourceFormSchema } from "./SidebarForm/ContainerResourceForm";
 import { createInputsSchemaValidation } from "./SidebarForm/PieceForm/validation";
 import { storageFormSchema } from "./SidebarForm/StorageForm";
-import SidebarSettingsForm, {
+import {
+  SidebarSettingsForm,
   WorkflowSettingsFormSchema,
+  type SidebarSettingsFormRef,
 } from "./SidebarSettingsForm";
 
 /**
@@ -42,8 +48,21 @@ const getId = (module_name: string) => {
   return `${module_name}_${uuidv4()}`;
 };
 
+const VisuallyHiddenInput = styled("input")({
+  clip: "rect(0 0 0 0)",
+  clipPath: "inset(50%)",
+  height: 1,
+  overflow: "hidden",
+  position: "absolute",
+  bottom: 0,
+  left: 0,
+  whiteSpace: "nowrap",
+  width: 1,
+});
+
 export const WorkflowsEditorComponent: React.FC = () => {
   const workflowPanelRef = useRef<WorkflowPanelRef>(null);
+  const sidebarSettingsRef = useRef<SidebarSettingsFormRef>(null);
   const [sidebarSettingsDrawer, setSidebarSettingsDrawer] = useState(false);
   const [sidebarPieceDrawer, setSidebarPieceDrawer] = useState(false);
   const [formId, setFormId] = useState<string>("");
@@ -55,6 +74,9 @@ export const WorkflowsEditorComponent: React.FC = () => {
     "horizontal",
   );
 
+  const incompatiblePiecesModalRef = useRef<ModalRef>(null);
+  const [incompatiblesPieces, setIncompatiblesPieces] = useState<string[]>([]);
+
   const { workspace } = useWorkspaces();
 
   const saveDataToLocalForage = useCallback(async () => {
@@ -70,7 +92,7 @@ export const WorkflowsEditorComponent: React.FC = () => {
 
   const {
     clearForageData,
-    workflowsEditorBodyFromFlowchart,
+    generateWorkflowsEditorBodyParams,
     fetchWorkflowForage,
     handleCreateWorkflow,
     fetchForagePieceById,
@@ -81,7 +103,8 @@ export const WorkflowsEditorComponent: React.FC = () => {
     removeForageWorkflowPiecesById,
     removeForageWorkflowPieceDataById,
     fetchWorkflowPieceById,
-    setForageWorkflowPiecesData,
+    setForageWorkflowPiecesDataById,
+    importWorkflowToForage,
     clearDownstreamDataById,
     setWorkflowEdges,
     setWorkflowNodes,
@@ -153,7 +176,7 @@ export const WorkflowsEditorComponent: React.FC = () => {
       await validateWorkflowPiecesData(payload);
       await validateWorkflowSettings(payload);
 
-      const data = await workflowsEditorBodyFromFlowchart();
+      const data = await generateWorkflowsEditorBodyParams(payload);
 
       await handleCreateWorkflow({ workspace_id: workspace?.id, ...data });
 
@@ -175,7 +198,7 @@ export const WorkflowsEditorComponent: React.FC = () => {
     handleCreateWorkflow,
     validateWorkflowPiecesData,
     validateWorkflowSettings,
-    workflowsEditorBodyFromFlowchart,
+    generateWorkflowsEditorBodyParams,
     workspace?.id,
   ]);
 
@@ -183,8 +206,109 @@ export const WorkflowsEditorComponent: React.FC = () => {
     await clearForageData();
     workflowPanelRef.current?.setEdges([]);
     workflowPanelRef.current?.setNodes([]);
+    await sidebarSettingsRef.current?.loadData();
   }, [clearForageData]);
 
+  const handleExport = useCallback(async () => {
+    await saveDataToLocalForage();
+    const payload = await fetchWorkflowForage();
+    if (Object.keys(payload.workflowPieces).length === 0) {
+      toast.error("Workflow must have at least one piece to be exported.");
+      return;
+    }
+    exportToJson(payload, payload.workflowSettingsData?.config?.name);
+  }, []);
+
+  const validateJsonImported = useCallback(
+    async (json: DominoWorkflowForage) => {
+      const getRepositories = function (
+        workflowPieces: DominoWorkflowForage["workflowPieces"],
+      ) {
+        return [
+          ...new Set(
+            Object.values(workflowPieces)
+              .reduce<Array<string | null>>((acc, next) => {
+                acc.push(next.source_image);
+                return acc;
+              }, [])
+              .filter((su) => !!su) as string[],
+          ),
+        ];
+      };
+
+      const currentRepositories = [
+        ...new Set(
+          Object.values((await localForage.getItem("pieces")) as any)?.map(
+            (p: any) => p?.source_image,
+          ),
+        ),
+      ];
+      const incomeRepositories = getRepositories(json.workflowPieces);
+
+      const differences = incomeRepositories.filter(
+        (x) => !currentRepositories.includes(x),
+      );
+
+      return differences.length ? differences : null;
+    },
+    [fetchWorkflowForage],
+  );
+
+  const fileInputRef = useRef<HTMLInputElement>(null);
+
+  const handleImport = useCallback(
+    (e: React.ChangeEvent<HTMLInputElement>) => {
+      const file = e.target.files?.[0];
+
+      if (file) {
+        const reader = new FileReader();
+
+        reader.onload = (e) => {
+          try {
+            const jsonData = JSON.parse(
+              e.target?.result as string,
+            ) as DominoWorkflowForage;
+
+            validateJsonImported(jsonData)
+              .then((diferences) => {
+                if (diferences) {
+                  toast.error(
+                    "Some repositories are missing or incompatible version",
+                  );
+                  setIncompatiblesPieces(diferences);
+                  incompatiblePiecesModalRef.current?.open();
+                  return;
+                }
+
+                workflowPanelRef?.current?.setNodes(jsonData.workflowNodes);
+                workflowPanelRef?.current?.setEdges(jsonData.workflowEdges);
+                void importWorkflowToForage(jsonData);
+              })
+              .catch((e) => {
+                console.log(e);
+              });
+
+            if (fileInputRef.current) {
+              fileInputRef.current.value = "";
+            }
+          } catch (error) {
+            console.error("Error parsing JSON file:", error);
+          }
+        };
+
+        reader.readAsText(file);
+      }
+    },
+    [
+      validateJsonImported,
+      workflowPanelRef,
+      importWorkflowToForage,
+      setIncompatiblesPieces,
+      incompatiblePiecesModalRef,
+      fileInputRef,
+    ],
+  );
+
   const onNodesDelete = useCallback(
     async (nodes: any) => {
       for (const node of nodes) {
@@ -267,7 +391,10 @@ export const WorkflowsEditorComponent: React.FC = () => {
         inputs: defaultInputs,
       };
 
-      await setForageWorkflowPiecesData(newNode.id, defaultWorkflowPieceData);
+      await setForageWorkflowPiecesDataById(
+        newNode.id,
+        defaultWorkflowPieceData,
+      );
       return newNode;
     },
     [
@@ -275,7 +402,7 @@ export const WorkflowsEditorComponent: React.FC = () => {
       fetchForagePieceById,
       setForageWorkflowPieces,
       getForageWorkflowPieces,
-      setForageWorkflowPiecesData,
+      setForageWorkflowPiecesDataById,
     ],
   );
 
@@ -344,11 +471,45 @@ export const WorkflowsEditorComponent: React.FC = () => {
               <Button
                 color="primary"
                 variant="contained"
+                startIcon={<IosShareIcon />}
+                onClick={handleExport}
+              >
+                Export
+              </Button>
+            </Grid>
+            <Grid item>
+              <Button
+                component="label"
+                variant="contained"
                 startIcon={<DownloadIcon />}
               >
-                Load
+                Import
+                <VisuallyHiddenInput
+                  type="file"
+                  onChange={handleImport}
+                  ref={fileInputRef}
+                />
+                <Modal
+                  title="Missing or incompatibles Pieces Repositories"
+                  content={
+                    <ul>
+                      {incompatiblesPieces.map((item) => (
+                        <li key={item}>
+                          {`${item.split("ghcr.io/")[1].split(":")[0]}:  ${
+                            item
+                              .split("ghcr.io/")[1]
+                              .split(":")[1]
+                              .split("-")[0]
+                          }`}
+                        </li>
+                      ))}
+                    </ul>
+                  }
+                  ref={incompatiblePiecesModalRef}
+                />
               </Button>
             </Grid>
+
             <Grid item>
               <Button
                 color="primary"
@@ -392,6 +553,7 @@ export const WorkflowsEditorComponent: React.FC = () => {
       <SidebarSettingsForm
         onClose={toggleSidebarSettingsDrawer(false)}
         open={sidebarSettingsDrawer}
+        ref={sidebarSettingsRef}
       />
     </>
   );
diff --git a/frontend/src/features/workflowEditor/context/types/workflowPieceData.ts b/frontend/src/features/workflowEditor/context/types/workflowPieceData.ts
index 0423aebc..73e76448 100644
--- a/frontend/src/features/workflowEditor/context/types/workflowPieceData.ts
+++ b/frontend/src/features/workflowEditor/context/types/workflowPieceData.ts
@@ -21,7 +21,7 @@ interface WorkflowBaseSettings {
   name: string;
   start_date: string; // ISOFormat
   select_end_date: EndDateTypes;
-  schedule_interval: ScheduleIntervals;
+  schedule: ScheduleIntervals;
 
   end_date?: string; // ISOFormat
   catchup?: boolean;
diff --git a/frontend/src/features/workflowEditor/context/workflowPiecesData.tsx b/frontend/src/features/workflowEditor/context/workflowPiecesData.tsx
index 7d6074b4..578ab218 100644
--- a/frontend/src/features/workflowEditor/context/workflowPiecesData.tsx
+++ b/frontend/src/features/workflowEditor/context/workflowPiecesData.tsx
@@ -4,13 +4,14 @@ import { createCustomContext, getUuid } from "utils";
 
 import { type IWorkflowPieceData } from "./types";
 
-type ForagePiecesData = Record<string, IWorkflowPieceData>;
+export type ForagePiecesData = Record<string, IWorkflowPieceData>;
 
 export interface IWorkflowPiecesDataContext {
-  setForageWorkflowPiecesData: (
+  setForageWorkflowPiecesDataById: (
     id: string,
     pieceData: IWorkflowPieceData,
   ) => Promise<void>;
+  setForageWorkflowPiecesData: (pieceData: ForagePiecesData) => Promise<void>;
   fetchForageWorkflowPiecesData: () => Promise<ForagePiecesData>;
   fetchForageWorkflowPiecesDataById: (
     id: string,
@@ -26,7 +27,7 @@ export const [WorkflowPiecesDataContext, useWorkflowPiecesData] =
 const WorkflowPiecesDataProvider: React.FC<{ children: React.ReactNode }> = ({
   children,
 }) => {
-  const setForageWorkflowPiecesData = useCallback(
+  const setForageWorkflowPiecesDataById = useCallback(
     async (id: string, pieceData: IWorkflowPieceData) => {
       let currentData =
         await localForage.getItem<ForagePiecesData>("workflowPiecesData");
@@ -38,6 +39,12 @@ const WorkflowPiecesDataProvider: React.FC<{ children: React.ReactNode }> = ({
     },
     [],
   );
+  const setForageWorkflowPiecesData = useCallback(
+    async (pieceData: ForagePiecesData) => {
+      await localForage.setItem("workflowPiecesData", pieceData);
+    },
+    [],
+  );
 
   const fetchForageWorkflowPiecesData = useCallback(async () => {
     const workflowPiecesData =
@@ -120,6 +127,7 @@ const WorkflowPiecesDataProvider: React.FC<{ children: React.ReactNode }> = ({
   }, []);
 
   const value: IWorkflowPiecesDataContext = {
+    setForageWorkflowPiecesDataById,
     setForageWorkflowPiecesData,
     fetchForageWorkflowPiecesData,
     fetchForageWorkflowPiecesDataById,
diff --git a/frontend/src/features/workflowEditor/context/workflowsEditor.tsx b/frontend/src/features/workflowEditor/context/workflowsEditor.tsx
index 01188487..2a430b6f 100644
--- a/frontend/src/features/workflowEditor/context/workflowsEditor.tsx
+++ b/frontend/src/features/workflowEditor/context/workflowsEditor.tsx
@@ -3,8 +3,12 @@ import {
   type IPostWorkflowParams,
   useAuthenticatedPostWorkflow,
 } from "features/workflows/api";
-import { type IPostWorkflowResponseInterface } from "features/workflows/types";
+import {
+  type IWorkflowElement,
+  type IPostWorkflowResponseInterface,
+} from "features/workflows/types";
 import React, { type FC, useCallback } from "react";
+import { type Edge } from "reactflow";
 import { createCustomContext, generateTaskName, getIdSlice } from "utils";
 
 import { usesPieces, type IPiecesContext } from "./pieces";
@@ -12,25 +16,47 @@ import {
   useReactWorkflowPersistence,
   type IReactWorkflowPersistenceContext,
 } from "./reactWorkflowPersistence";
-import { type CreateWorkflowRequest, type TasksDataModel } from "./types";
+import {
+  type IWorkflowSettings,
+  type CreateWorkflowRequest,
+  type TasksDataModel,
+} from "./types";
 import { useWorkflowPiece, type IWorkflowPieceContext } from "./workflowPieces";
 import {
   useWorkflowPiecesData,
   type IWorkflowPiecesDataContext,
+  type ForagePiecesData,
 } from "./workflowPiecesData";
 import {
   type IWorkflowSettingsContext,
   useWorkflowSettings,
 } from "./workflowSettingsData";
 
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+type GenerateWorkflowsParams = {
+  workflowPiecesData: ForagePiecesData;
+  workflowSettingsData: IWorkflowSettings;
+  workflowNodes: IWorkflowElement[];
+  workflowEdges: Edge[];
+};
+
+export type DominoWorkflowForage = GenerateWorkflowsParams & {
+  workflowPieces: Record<string, Piece>;
+};
+
 interface IWorkflowsEditorContext
   extends IPiecesContext,
     IReactWorkflowPersistenceContext,
     IWorkflowSettingsContext,
     IWorkflowPieceContext,
     IWorkflowPiecesDataContext {
-  fetchWorkflowForage: () => any; // TODO add type
-  workflowsEditorBodyFromFlowchart: () => Promise<CreateWorkflowRequest>; // TODO add type
+  fetchWorkflowForage: () => Promise<DominoWorkflowForage>;
+  importWorkflowToForage: (
+    importedWorkflow: DominoWorkflowForage,
+  ) => Promise<void>;
+  generateWorkflowsEditorBodyParams: (
+    p: GenerateWorkflowsParams,
+  ) => Promise<CreateWorkflowRequest>;
   handleCreateWorkflow: (
     params: IPostWorkflowParams,
   ) => Promise<IPostWorkflowResponseInterface>;
@@ -78,6 +104,7 @@ const WorkflowsEditorProvider: FC<{ children?: React.ReactNode }> = ({
     fetchForageWorkflowPiecesData,
     fetchForageWorkflowPiecesDataById,
     setForageWorkflowPiecesData,
+    setForageWorkflowPiecesDataById,
     clearForageWorkflowPiecesData,
     removeForageWorkflowPieceDataById,
     clearDownstreamDataById,
@@ -103,149 +130,175 @@ const WorkflowsEditorProvider: FC<{ children?: React.ReactNode }> = ({
     const workflowPieces = await getForageWorkflowPieces();
     const workflowPiecesData = await fetchForageWorkflowPiecesData();
     const workflowSettingsData = await fetchWorkflowSettingsData();
-
-    return {
+    const workflowNodes = await fetchForageWorkflowNodes();
+    const workflowEdges = await fetchForageWorkflowEdges();
+    const result: DominoWorkflowForage = {
       workflowPieces,
       workflowPiecesData,
       workflowSettingsData,
+      workflowNodes,
+      workflowEdges,
     };
+    return result;
   }, [
     fetchForageWorkflowPiecesData,
     fetchWorkflowSettingsData,
     getForageWorkflowPieces,
   ]);
 
-  const workflowsEditorBodyFromFlowchart = useCallback(async () => {
-    const workflowPiecesData = await fetchForageWorkflowPiecesData();
-    const workflowSettingsData = await fetchWorkflowSettingsData();
-    const workflowNodes = await fetchForageWorkflowNodes();
-    const workflowEdges = await fetchForageWorkflowEdges();
+  const importWorkflowToForage = useCallback(
+    async (dominoWorkflow: DominoWorkflowForage) => {
+      await setForageWorkflowPieces(dominoWorkflow.workflowPieces);
+      await setForageWorkflowPiecesData(dominoWorkflow.workflowPiecesData);
+      await setWorkflowSettingsData(dominoWorkflow.workflowSettingsData);
+      await setWorkflowNodes(dominoWorkflow.workflowNodes);
+      await setWorkflowEdges(dominoWorkflow.workflowEdges);
+    },
+    [
+      setForageWorkflowPieces,
+      setForageWorkflowPiecesData,
+      setWorkflowSettingsData,
+      setWorkflowNodes,
+      setWorkflowEdges,
+    ],
+  );
 
-    const workflow: CreateWorkflowRequest["workflow"] = {
-      name: workflowSettingsData.config.name,
-      schedule_interval: workflowSettingsData.config.scheduleInterval,
-      select_end_date: workflowSettingsData.config.endDateType,
-      start_date: workflowSettingsData.config.startDate,
-      end_date: workflowSettingsData.config.endDate,
-    };
+  const generateWorkflowsEditorBodyParams = useCallback(
+    async ({
+      workflowPiecesData,
+      workflowSettingsData,
+      workflowNodes,
+      workflowEdges,
+    }: GenerateWorkflowsParams) => {
+      const workflow: CreateWorkflowRequest["workflow"] = {
+        name: workflowSettingsData.config.name,
+        schedule: workflowSettingsData.config.scheduleInterval,
+        select_end_date: workflowSettingsData.config.endDateType,
+        start_date: workflowSettingsData.config.startDate,
+        end_date: workflowSettingsData.config.endDate,
+      };
 
-    const ui_schema: CreateWorkflowRequest["ui_schema"] = {
-      nodes: {},
-      edges: workflowEdges,
-    };
+      const ui_schema: CreateWorkflowRequest["ui_schema"] = {
+        nodes: {},
+        edges: workflowEdges,
+      };
 
-    const tasks: CreateWorkflowRequest["tasks"] = {};
+      const tasks: CreateWorkflowRequest["tasks"] = {};
 
-    for (const element of workflowNodes) {
-      const elementData = workflowPiecesData[element.id];
+      for (const element of workflowNodes) {
+        const elementData = workflowPiecesData[element.id];
 
-      const numberId = getIdSlice(element.id);
-      const taskName = generateTaskName(element.data.name, element.id);
+        const numberId = getIdSlice(element.id);
+        const taskName = generateTaskName(element.data.name, element.id);
 
-      ui_schema.nodes[taskName] = element;
+        ui_schema.nodes[taskName] = element;
 
-      const dependencies = workflowEdges.reduce<string[]>(
-        (acc: string[], edge: { target: any; source: any }) => {
-          if (edge.target === element.id) {
-            const task = workflowNodes.find(
-              (n: { id: any }) => n.id === edge.source,
-            );
-            if (task) {
-              const upTaskName = generateTaskName(task.data.name, task.id);
-              acc.push(upTaskName);
+        const dependencies = workflowEdges.reduce<string[]>(
+          (acc: string[], edge: { target: any; source: any }) => {
+            if (edge.target === element.id) {
+              const task = workflowNodes.find(
+                (n: { id: any }) => n.id === edge.source,
+              );
+              if (task) {
+                const upTaskName = generateTaskName(task.data.name, task.id);
+                acc.push(upTaskName);
+              }
             }
-          }
 
-          return acc;
-        },
-        [],
-      );
-
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      const { storageSource, baseFolder, ...providerOptions } =
-        workflowSettingsData.storage || {};
-
-      const workflowSharedStorage = {
-        source: storageSource,
-        ...{ mode: elementData?.storage?.storageAccessMode },
-        provider_options: {
-          ...(providerOptions && providerOptions.bucket !== ""
-            ? { bucket: providerOptions.bucket, base_folder: baseFolder }
-            : {}),
-        },
-      };
+            return acc;
+          },
+          [],
+        );
+
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { storageSource, baseFolder, ...providerOptions } =
+          workflowSettingsData.storage || {};
+
+        const workflowSharedStorage = {
+          source: storageSource,
+          ...{ mode: elementData?.storage?.storageAccessMode },
+          provider_options: {
+            ...(providerOptions && providerOptions.bucket !== ""
+              ? { bucket: providerOptions.bucket, base_folder: baseFolder }
+              : {}),
+          },
+        };
+
+        const pieceInputKwargs = Object.entries(elementData.inputs).reduce<
+          Record<string, any>
+        >((acc, [key, value]) => {
+          if (Array.isArray(value.value)) {
+            acc[key] = {
+              fromUpstream: value.fromUpstream,
+              upstreamTaskId: value.fromUpstream ? value.upstreamId : null,
+              upstreamArgument: value.fromUpstream
+                ? value.upstreamArgument
+                : null,
+              value: value.value.map((value) => {
+                return {
+                  fromUpstream: value.fromUpstream,
+                  upstreamTaskId: value.fromUpstream ? value.upstreamId : null,
+                  upstreamArgument: value.fromUpstream
+                    ? value.upstreamArgument
+                    : null,
+                  value: value.value,
+                };
+              }),
+            };
+
+            return acc;
+          }
 
-      const pieceInputKwargs = Object.entries(elementData.inputs).reduce<
-        Record<string, any>
-      >((acc, [key, value]) => {
-        if (Array.isArray(value.value)) {
           acc[key] = {
             fromUpstream: value.fromUpstream,
             upstreamTaskId: value.fromUpstream ? value.upstreamId : null,
             upstreamArgument: value.fromUpstream
               ? value.upstreamArgument
               : null,
-            value: value.value.map((value) => {
-              return {
-                fromUpstream: value.fromUpstream,
-                upstreamTaskId: value.fromUpstream ? value.upstreamId : null,
-                upstreamArgument: value.fromUpstream
-                  ? value.upstreamArgument
-                  : null,
-                value: value.value,
-              };
-            }),
+            value: value.value,
           };
 
           return acc;
-        }
-
-        acc[key] = {
-          fromUpstream: value.fromUpstream,
-          upstreamTaskId: value.fromUpstream ? value.upstreamId : null,
-          upstreamArgument: value.fromUpstream ? value.upstreamArgument : null,
-          value: value.value,
-        };
+        }, {});
 
-        return acc;
-      }, {});
-
-      const taskDataModel: TasksDataModel = {
-        task_id: taskName,
-        piece: {
-          id: numberId,
-          name: element.data.name,
-        },
-        dependencies,
-        piece_input_kwargs: pieceInputKwargs,
-        workflow_shared_storage: workflowSharedStorage,
-        container_resources: {
-          requests: {
-            cpu: elementData.containerResources.cpu.min,
-            memory: elementData.containerResources.memory.min,
+        const taskDataModel: TasksDataModel = {
+          task_id: taskName,
+          piece: {
+            id: numberId,
+            name: element.data.name,
           },
-          limits: {
-            cpu: elementData.containerResources.cpu.max,
-            memory: elementData.containerResources.memory.max,
+          dependencies,
+          piece_input_kwargs: pieceInputKwargs,
+          workflow_shared_storage: workflowSharedStorage,
+          container_resources: {
+            requests: {
+              cpu: elementData.containerResources.cpu.min,
+              memory: elementData.containerResources.memory.min,
+            },
+            limits: {
+              cpu: elementData.containerResources.cpu.max,
+              memory: elementData.containerResources.memory.max,
+            },
+            use_gpu: elementData.containerResources.useGpu,
           },
-          use_gpu: elementData.containerResources.useGpu,
-        },
-      };
+        };
 
-      tasks[taskName] = taskDataModel;
-    }
+        tasks[taskName] = taskDataModel;
+      }
 
-    return {
-      workflow,
-      tasks,
-      ui_schema,
-    };
-  }, [
-    fetchForageWorkflowEdges,
-    fetchForageWorkflowNodes,
-    fetchForageWorkflowPiecesData,
-    fetchWorkflowSettingsData,
-  ]);
+      return {
+        workflow,
+        tasks,
+        ui_schema,
+      };
+    },
+    [
+      fetchForageWorkflowEdges,
+      fetchForageWorkflowNodes,
+      fetchForageWorkflowPiecesData,
+      fetchWorkflowSettingsData,
+    ],
+  );
 
   const clearForageData = useCallback(async () => {
     await Promise.allSettled([
@@ -271,6 +324,8 @@ const WorkflowsEditorProvider: FC<{ children?: React.ReactNode }> = ({
     search,
     handleSearch,
 
+    importWorkflowToForage,
+
     setWorkflowEdges,
     setWorkflowNodes,
     fetchForageWorkflowEdges,
@@ -285,6 +340,7 @@ const WorkflowsEditorProvider: FC<{ children?: React.ReactNode }> = ({
     clearForageWorkflowPieces,
 
     setForageWorkflowPiecesData,
+    setForageWorkflowPiecesDataById,
     fetchForageWorkflowPiecesData,
     fetchForageWorkflowPiecesDataById,
     removeForageWorkflowPieceDataById,
@@ -297,7 +353,7 @@ const WorkflowsEditorProvider: FC<{ children?: React.ReactNode }> = ({
 
     handleCreateWorkflow,
     fetchWorkflowForage,
-    workflowsEditorBodyFromFlowchart,
+    generateWorkflowsEditorBodyParams,
     clearForageData,
   };
 
diff --git a/frontend/src/features/workflows/components/WorkflowDetail/CustomTabMenu/TaskResult.tsx b/frontend/src/features/workflows/components/WorkflowDetail/CustomTabMenu/TaskResult.tsx
index 85f1f785..35314721 100644
--- a/frontend/src/features/workflows/components/WorkflowDetail/CustomTabMenu/TaskResult.tsx
+++ b/frontend/src/features/workflows/components/WorkflowDetail/CustomTabMenu/TaskResult.tsx
@@ -14,6 +14,7 @@ export const TaskResult = (props: ITaskResultProps) => {
 
   const style: CSSProperties = {
     height: "100%",
+    width: "100%",
     overflowY: "scroll",
     overflowX: "hidden",
     wordWrap: "break-word",
diff --git a/frontend/src/features/workflows/components/WorkflowsList/Actions.tsx b/frontend/src/features/workflows/components/WorkflowsList/Actions.tsx
index 830f2ce5..883e01b4 100644
--- a/frontend/src/features/workflows/components/WorkflowsList/Actions.tsx
+++ b/frontend/src/features/workflows/components/WorkflowsList/Actions.tsx
@@ -3,10 +3,10 @@ import PauseCircleOutlineIcon from "@mui/icons-material/PauseCircleOutline";
 import PlayCircleOutlineIcon from "@mui/icons-material/PlayCircleOutline";
 import { IconButton } from "@mui/material";
 import { type CommonProps } from "@mui/material/OverridableComponent";
-import { NewFeatureDialog } from "components/NewFeatureDialog";
+import { Modal, type ModalRef } from "components/Modal";
 import { type IWorkflow } from "features/workflows/types";
 import theme from "providers/theme.config";
-import React, { useState } from "react";
+import React, { useRef, useState } from "react";
 
 import { ConfirmDeleteModal } from "./ConfirmDeleteModal";
 
@@ -19,7 +19,7 @@ interface Props extends CommonProps {
 
 export const Actions: React.FC<Props> = ({ runFn, deleteFn, className }) => {
   const [deleteModalOpen, setDeleteModalOpen] = useState(false);
-  const [newFeatureModal, setNewFeatureModal] = useState(false);
+  const newFeatureModal = useRef<ModalRef>(null);
 
   return (
     <>
@@ -31,7 +31,7 @@ export const Actions: React.FC<Props> = ({ runFn, deleteFn, className }) => {
       <IconButton
         className={className}
         onClick={() => {
-          setNewFeatureModal(true);
+          newFeatureModal.current?.open();
         }}
       >
         <PauseCircleOutlineIcon
@@ -48,11 +48,11 @@ export const Actions: React.FC<Props> = ({ runFn, deleteFn, className }) => {
           style={{ pointerEvents: "none", color: theme.palette.error.main }}
         />
       </IconButton>
-      <NewFeatureDialog
-        isOpen={newFeatureModal}
-        confirmFn={() => {
-          setNewFeatureModal(false);
-        }}
+      <Modal
+        title="New Feature"
+        content="This feature is not ready yet! We launch new versions every time,
+          check out our changelog for more information !"
+        ref={newFeatureModal}
       />
       <ConfirmDeleteModal
         isOpen={deleteModalOpen}
diff --git a/frontend/src/features/workflows/components/WorkflowsList/index.tsx b/frontend/src/features/workflows/components/WorkflowsList/index.tsx
index 6f751985..50fa55f9 100644
--- a/frontend/src/features/workflows/components/WorkflowsList/index.tsx
+++ b/frontend/src/features/workflows/components/WorkflowsList/index.tsx
@@ -1,6 +1,7 @@
 import { Paper } from "@mui/material";
 import {
   DataGrid,
+  type GridRowParams,
   type GridColDef,
   type GridEventListener,
 } from "@mui/x-data-grid";
@@ -39,6 +40,7 @@ export const WorkflowList: React.FC = () => {
     paginationModel.page,
     paginationModel.pageSize,
   );
+
   const handleDeleteWorkflow = useAuthenticatedDeleteWorkflowId();
   const handleRunWorkflow = useAuthenticatedPostWorkflowRunId();
 
@@ -106,12 +108,22 @@ export const WorkflowList: React.FC = () => {
         headerAlign: "center",
       },
       {
-        field: "schedule_interval",
-        headerName: "Schedule Interval",
+        field: "schedule",
+        headerName: "Schedule",
+        flex: 1,
+        align: "center",
+        headerAlign: "center",
+        sortable: false,
+      },
+      {
+        field: "next_dagrun",
+        headerName: "Next Run",
         flex: 1,
         align: "center",
         headerAlign: "center",
         sortable: false,
+        valueFormatter: ({ value }) =>
+          value ? new Date(value).toLocaleString() : "none",
       },
       {
         field: "actions",
@@ -141,13 +153,13 @@ export const WorkflowList: React.FC = () => {
   );
 
   const handleRowClick = useCallback<GridEventListener<"rowClick">>(
-    (row, event) => {
+    (params: GridRowParams<IWorkflow>, event) => {
       const isActionButtonClick =
         event.target instanceof Element &&
         event.target.classList.contains(".action-button");
       if (!isActionButtonClick) {
-        // Handle row click logic only if it's not an action button click
-        navigate(`/workflows/${row.id}`);
+        if (params.row.status !== "failed" && params.row.status !== "creating")
+          navigate(`/workflows/${params.id}`);
       }
     },
     [navigate],
@@ -166,6 +178,9 @@ export const WorkflowList: React.FC = () => {
           density="comfortable"
           columns={columns}
           rows={rows}
+          isRowSelectable={(params) =>
+            params.row.status !== "failed" && params.row.status !== "creating"
+          }
           onRowClick={handleRowClick}
           pagination
           paginationMode="server"
diff --git a/frontend/src/features/workflows/types/workflow.ts b/frontend/src/features/workflows/types/workflow.ts
index 0065ac5e..d6f52690 100644
--- a/frontend/src/features/workflows/types/workflow.ts
+++ b/frontend/src/features/workflows/types/workflow.ts
@@ -30,7 +30,7 @@ export interface IWorkflow {
   status: workflowStatus;
   is_subdag: boolean;
   last_pickled: string;
-  schedule_interval: string;
+  schedule: string;
   max_active_tasks: number;
   max_active_runs: number;
   has_task_concurrency_limits: boolean;
@@ -61,7 +61,7 @@ export interface IWorkflowConfig {
   name: string;
   start_date: string;
   end_date: string;
-  schedule_interval: string;
+  schedule: string;
   catchup: boolean;
   generate_report: string;
   description: string;
diff --git a/frontend/src/utils/downloadJson.ts b/frontend/src/utils/downloadJson.ts
new file mode 100644
index 00000000..3223efef
--- /dev/null
+++ b/frontend/src/utils/downloadJson.ts
@@ -0,0 +1,26 @@
+export const exportToJson = (
+  objectData: Record<string, unknown>,
+  filename = "export.json",
+) => {
+  const contentType = "application/json;charset=utf-8;";
+  const navigator = window.navigator as any;
+  if (navigator?.msSaveOrOpenBlob) {
+    const blob = new Blob(
+      [decodeURIComponent(encodeURI(JSON.stringify(objectData)))],
+      { type: contentType },
+    );
+    navigator.msSaveOrOpenBlob(blob, filename);
+  } else {
+    const a = document.createElement("a");
+    a.download = filename;
+    a.href =
+      "data:" +
+      contentType +
+      "," +
+      encodeURIComponent(JSON.stringify(objectData));
+    a.target = "_blank";
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+  }
+};
diff --git a/frontend/src/utils/index.ts b/frontend/src/utils/index.ts
index 9df3ba86..52c478d7 100644
--- a/frontend/src/utils/index.ts
+++ b/frontend/src/utils/index.ts
@@ -7,3 +7,4 @@ export { getDefinition } from "./getDefinition";
 export { lazyImport } from "./lazyImports";
 export { useInterval } from "./useInterval";
 export { useMouseProximity } from "./useMouseProximity";
+export { exportToJson } from "./downloadJson";
diff --git a/frontend/tsconfig.json b/frontend/tsconfig.json
index 4b624b36..f660d6db 100644
--- a/frontend/tsconfig.json
+++ b/frontend/tsconfig.json
@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "target": "es5",
+    "target": "es2015",
     "lib": [
       "dom",
       "dom.iterable",
diff --git a/rest/core/settings.py b/rest/core/settings.py
index b128bf38..e2409914 100644
--- a/rest/core/settings.py
+++ b/rest/core/settings.py
@@ -50,7 +50,7 @@ class Settings(BaseSettings):
 
     # Default domino pieces repository
     DOMINO_DEFAULT_PIECES_REPOSITORY = os.environ.get('DOMINO_DEFAULT_PIECES_REPOSITORY', "Tauffer-Consulting/default_domino_pieces")
-    DOMINO_DEFAULT_PIECES_REPOSITORY_VERSION = os.environ.get('DOMINO_DEFAULT_PIECES_REPOSITORY_VERSION', "0.4.2")
+    DOMINO_DEFAULT_PIECES_REPOSITORY_VERSION = os.environ.get('DOMINO_DEFAULT_PIECES_REPOSITORY_VERSION', "0.4.3")
     DOMINO_DEFAULT_PIECES_REPOSITORY_SOURCE = os.environ.get('DOMINO_DEFAULT_PIECES_REPOSITORY_SOURCE', "github")
     DOMINO_DEFAULT_PIECES_REPOSITORY_TOKEN: EmptyStrToNone = os.environ.get('DOMINO_DEFAULT_PIECES_REPOSITORY_TOKEN', "")
     DOMINO_DEFAULT_PIECES_REPOSITORY_URL: str = os.environ.get('DOMINO_DEFAULT_PIECES_REPOSITORY_URL', 'https://github.com/Tauffer-Consulting/default_domino_pieces')
diff --git a/rest/database/alembic/versions/758034ba1a89_.py b/rest/database/alembic/versions/758034ba1a89_.py
new file mode 100644
index 00000000..6a2f312b
--- /dev/null
+++ b/rest/database/alembic/versions/758034ba1a89_.py
@@ -0,0 +1,30 @@
+"""empty message
+
+Revision ID: 758034ba1a89
+Revises: c25e53090da7
+Create Date: 2023-10-30 13:58:20.061180
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision = '758034ba1a89'
+down_revision = 'c25e53090da7'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('workflow', sa.Column('schedule', sa.Enum('none', 'once', 'hourly', 'daily', 'weekly', 'monthly', 'yearly', 'Config', name='workflowscheduleinterval'), nullable=True))
+    op.drop_column('workflow', 'schedule_interval')
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('workflow', sa.Column('schedule_interval', postgresql.ENUM('none', 'once', 'hourly', 'daily', 'weekly', 'monthly', 'yearly', 'Config', name='workflowscheduleinterval'), autoincrement=False, nullable=True))
+    op.drop_column('workflow', 'schedule')
+    # ### end Alembic commands ###
diff --git a/rest/database/models/workflow.py b/rest/database/models/workflow.py
index 1b8069bc..7da4620b 100644
--- a/rest/database/models/workflow.py
+++ b/rest/database/models/workflow.py
@@ -18,7 +18,7 @@ class Workflow(Base):
     last_changed_at = Column(DateTime, nullable=False, default=datetime.utcnow)
     start_date = Column(DateTime, nullable=True)
     end_date = Column(DateTime, nullable=True)
-    schedule_interval = Column(Enum(WorkflowScheduleInterval), nullable=True, default=WorkflowScheduleInterval.none.value)
+    schedule = Column(Enum(WorkflowScheduleInterval), nullable=True, default=WorkflowScheduleInterval.none.value)
     workspace_id = Column(Integer, ForeignKey("workspace.id", ondelete='cascade'), nullable=False)
     last_changed_by = Column(Integer, ForeignKey("user.id"), nullable=False)
 
diff --git a/rest/populate_db.py b/rest/populate_db.py
deleted file mode 100644
index f185b8f2..00000000
--- a/rest/populate_db.py
+++ /dev/null
@@ -1,20 +0,0 @@
-import argparse
-from sqlalchemy import create_engine
-
-
-if __name__ == "__main__":
-    # Parse command-line arguments
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--user", required=True)
-    parser.add_argument("--password", required=True)
-    parser.add_argument("--host", required=True)
-    args = parser.parse_args()
-
-    # Create database engine
-    engine = create_engine(f"postgresql://{args.user}:{args.password}@{args.host}/mydb")
-
-    # Write initial data to the database using SQLAlchemy
-    with engine.connect() as conn:
-        conn.execute("INSERT INTO users (username, password) VALUES ('user1', 'password1')")
-        conn.execute("INSERT INTO users (username, password) VALUES ('user2', 'password2')")
-        conn.execute("INSERT INTO users (username, password) VALUES ('user3', 'password3')")
diff --git a/rest/repository/workflow_repository.py b/rest/repository/workflow_repository.py
index 8083fa9c..1d766977 100644
--- a/rest/repository/workflow_repository.py
+++ b/rest/repository/workflow_repository.py
@@ -131,7 +131,7 @@ def update(self, workflow: Workflow):
             saved_workflow.last_changed_at = workflow.last_changed_at
             saved_workflow.start_date = workflow.start_date
             saved_workflow.end_date = workflow.end_date
-            saved_workflow.schedule_interval = workflow.schedule_interval
+            saved_workflow.schedule = workflow.schedule
             saved_workflow.last_changed_by = workflow.last_changed_by
             session.flush()
             session.expunge(saved_workflow)
diff --git a/rest/schemas/requests/workflow.py b/rest/schemas/requests/workflow.py
index 671c1cbe..c3dd4fa3 100644
--- a/rest/schemas/requests/workflow.py
+++ b/rest/schemas/requests/workflow.py
@@ -41,7 +41,7 @@ class WorkflowBaseSettings(BaseModel):
     start_date: str = Field(alias="startDateTime")
     select_end_date: Optional[SelectEndDate] = Field(alias="selectEndDate", default=SelectEndDate.never)
     end_date: Optional[str] = Field(alias='endDateTime')
-    schedule_interval: ScheduleIntervalType = Field(alias="scheduleInterval")
+    schedule: ScheduleIntervalType = Field(alias="scheduleInterval")
     catchup: Optional[bool] = False # TODO add catchup to UI?
     generate_report: Optional[bool] = Field(alias="generateReport", default=False) # TODO add generate report to UI?
     description: Optional[str] # TODO add description to UI?
@@ -159,5 +159,5 @@ class ListWorkflowsFilters(BaseModel):
     start_date__gt: Optional[str]
     end_date: Optional[str]
     end_date__gt: Optional[str]
-    schedule_interval: Optional[ScheduleIntervalType]
+    schedule: Optional[ScheduleIntervalType]
 
diff --git a/rest/schemas/responses/workflow.py b/rest/schemas/responses/workflow.py
index 62a4a3a4..1a040591 100644
--- a/rest/schemas/responses/workflow.py
+++ b/rest/schemas/responses/workflow.py
@@ -1,6 +1,6 @@
 from schemas.responses.base import PaginationSet
 from pydantic import BaseModel, Field, validator
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Dict, Optional, List, Union
 from enum import Enum
 
@@ -48,15 +48,15 @@ class WorkflowConfigResponse(BaseModel):
     name: str
     start_date: str
     end_date: Optional[str]
-    schedule_interval: Optional[ScheduleIntervalTypeResponse]
+    schedule: Optional[ScheduleIntervalTypeResponse]
     catchup: bool = False
     generate_report: bool = False
     description: Optional[str]
 
 
-    @validator('schedule_interval')
-    def set_schedule_interval(cls, schedule_interval):
-        return schedule_interval or ScheduleIntervalTypeResponse.none
+    @validator('schedule')
+    def set_schedule(cls, schedule):
+        return schedule or ScheduleIntervalTypeResponse.none
     
 class BaseWorkflowModel(BaseModel):
     workflow: WorkflowConfigResponse
@@ -76,11 +76,31 @@ class GetWorkflowsResponseData(BaseModel):
     is_paused: bool
     is_active: bool
     status: WorkflowStatus
-    schedule_interval: Optional[ScheduleIntervalTypeResponse]
+    schedule: Optional[ScheduleIntervalTypeResponse]
+    next_dagrun: Optional[datetime]
 
-    @validator('schedule_interval')
-    def set_schedule_interval(cls, schedule_interval):
-        return schedule_interval or ScheduleIntervalTypeResponse.none
+    @validator('schedule')
+    def set_schedule(cls, schedule):
+        return schedule or ScheduleIntervalTypeResponse.none
+    
+
+    @validator('created_at', pre=True, always=True)
+    def add_utc_timezone_created_at(cls, v):
+        if isinstance(v, datetime) and v.tzinfo is None:
+            v = v.replace(tzinfo=timezone.utc)
+        return v
+    
+    @validator('last_changed_at', pre=True, always=True)
+    def add_utc_timezone_last_changed_at(cls, v):
+        if isinstance(v, datetime) and v.tzinfo is None:
+            v = v.replace(tzinfo=timezone.utc)
+        return v
+    
+    @validator('next_dagrun', pre=True, always=True)
+    def add_utc_timezone_next_dagrun(cls, v):
+        if isinstance(v, datetime) and v.tzinfo is None:
+            v = v.replace(tzinfo=timezone.utc)
+        return v
 
 class GetWorkflowsResponse(BaseModel):
     data: List[GetWorkflowsResponseData]
@@ -107,7 +127,7 @@ class GetWorkflowResponse(BaseModel):
     is_subdag: Optional[Union[bool, WorkflowStatus]] # Whether the DAG is SubDAG.
     last_pickled: Optional[Union[datetime, WorkflowStatus]] # The last time the DAG was pickled.
     last_expired: Optional[Union[datetime, WorkflowStatus]] # Time when the DAG last received a refresh signal (e.g. the DAG's "refresh" button was clicked in the web UI)
-    schedule_interval: Optional[Union[ScheduleIntervalTypeResponse, WorkflowStatus]] # The schedule interval for the DAG.
+    schedule: Optional[Union[ScheduleIntervalTypeResponse, WorkflowStatus]] # The schedule interval for the DAG.
     max_active_tasks: Optional[Union[int, WorkflowStatus]]  # Maximum number of active tasks that can be run on the DAG
     max_active_runs: Optional[Union[int, WorkflowStatus]] # Maximum number of active DAG runs for the DAG
     has_task_concurrency_limits: Optional[Union[bool, WorkflowStatus]] # Whether the DAG has task concurrency limits
@@ -116,9 +136,9 @@ class GetWorkflowResponse(BaseModel):
     next_dagrun_data_interval_start: Optional[Union[datetime, WorkflowStatus]] # The start date of the next dag run.
     next_dagrun_data_interval_end: Optional[Union[datetime, WorkflowStatus]] # The end date of the next dag run.
 
-    @validator('schedule_interval')
-    def set_schedule_interval(cls, schedule_interval):
-        return schedule_interval or ScheduleIntervalTypeResponse.none
+    @validator('schedule')
+    def set_schedule(cls, schedule):
+        return schedule or ScheduleIntervalTypeResponse.none
 
 
 class GetWorkflowRunsResponseData(BaseModel):
diff --git a/rest/services/secret_service.py b/rest/services/secret_service.py
index 9bf276c3..c43f9bb4 100644
--- a/rest/services/secret_service.py
+++ b/rest/services/secret_service.py
@@ -131,4 +131,5 @@ def get_piece_secrets(
                     value=decoded_value
                 )
             )
+
         return response
\ No newline at end of file
diff --git a/rest/services/workflow_service.py b/rest/services/workflow_service.py
index 9706ba0b..518ab21f 100644
--- a/rest/services/workflow_service.py
+++ b/rest/services/workflow_service.py
@@ -84,7 +84,7 @@ def create_workflow(
             last_changed_at=datetime.utcnow(),
             start_date=body.workflow.start_date,
             end_date=body.workflow.end_date,
-            schedule_interval=body.workflow.schedule_interval,
+            schedule=body.workflow.schedule,
             last_changed_by=auth_context.user_id,
             workspace_id=workspace_id
         )
@@ -192,25 +192,27 @@ async def list_workflows(
 
             is_dag_broken = dag_uuid in import_errors_uuids
 
-            schedule_interval = 'none'
+            schedule = 'none'
             is_active = False
             is_paused = False
+            next_dagrun = None
             status = WorkflowStatus.creating.value
             if is_dag_broken:
                 status = WorkflowStatus.failed.value
-                schedule_interval = 'failed'
+                schedule = 'failed'
                 is_active = False
                 is_paused = False
 
             if response and not is_dag_broken:
-                schedule_interval = response.get("schedule_interval")
-                if isinstance(schedule_interval, dict):
-                    schedule_interval = schedule_interval.get("value")
+                schedule = response.get("schedule")
+                if isinstance(schedule, dict):
+                    schedule = schedule.get("value")
                 status = WorkflowStatus.active.value
 
                 is_paused = response.get("is_paused")
                 is_active = response.get("is_active")
-
+                next_dagrun = response.get("next_dagrun")
+            
             data.append(
                 GetWorkflowsResponseData(
                     id=dag_data.id,
@@ -223,7 +225,8 @@ async def list_workflows(
                     is_paused=is_paused,
                     is_active=is_active,
                     status=status,
-                    schedule_interval=schedule_interval
+                    schedule=schedule,
+                    next_dagrun=next_dagrun
                 )
             )
 
@@ -259,7 +262,7 @@ def get_workflow(self, workspace_id: int, workflow_id: str, auth_context: Author
                 'is_subdag': 'creating',
                 'last_pickled': 'creating',
                 'last_expired': 'creating',
-                'schedule_interval': 'creating',
+                'schedule': 'creating',
                 'max_active_tasks': 'creating',
                 'max_active_runs': 'creating',
                 'has_task_concurrency_limits': 'creating',
@@ -271,9 +274,10 @@ def get_workflow(self, workspace_id: int, workflow_id: str, auth_context: Author
         else:
             airflow_dag_info = airflow_dag_info.json()
         
-        schedule_interval = airflow_dag_info.pop("schedule_interval")
-        if isinstance(schedule_interval, dict):
-            schedule_interval = schedule_interval.get("value")
+        # Airflow 2.4.0 deprecated schedule_interval in dag but the API (2.7.2) still using it
+        schedule = airflow_dag_info.pop("schedule_interval")
+        if isinstance(schedule, dict):
+            schedule = schedule.get("value")
 
         response = GetWorkflowResponse(
             id=workflow.id,
@@ -285,7 +289,7 @@ def get_workflow(self, workspace_id: int, workflow_id: str, auth_context: Author
             last_changed_by=workflow.last_changed_by,
             created_by=workflow.created_by,
             workspace_id=workflow.workspace_id,
-            schedule_interval=schedule_interval,
+            schedule=schedule,
             **airflow_dag_info
         )
 
@@ -349,7 +353,7 @@ def _validate_workflow_tasks(self, tasks_dict: dict, workspace_id: int):
             )
             for secret in piece_secrets:
                 if not secret.value:
-                    raise ResourceNotFoundException(f"Piece {piece.name} have missing secrets.")
+                    raise ResourceNotFoundException(f"Secret {secret.name} missing for {piece.name}.")
         return True
 
     def _get_storage_repository_from_tasks(self, tasks: list, workspace_id: int):
@@ -392,13 +396,13 @@ def _create_dag_code_from_raw_json(self, data: dict, workspace_id: int):
         """
         Format workflow kwargs to the formmate required by airflow. It should contain only the following kwargs:
         - dag_id
-        - schedule_interval
+        - schedule
         - start_date
         - end_date (not none)
         """
         workflow_kwargs['dag_id'] = workflow_kwargs.pop('id')
         select_end_date = workflow_kwargs.pop('select_end_date') # TODO define how to use select end date
-        workflow_kwargs['schedule_interval'] = None if workflow_kwargs['schedule_interval'] == 'none' else f"@{workflow_kwargs['schedule_interval']}"
+        workflow_kwargs['schedule'] = None if workflow_kwargs['schedule'] == 'none' else f"@{workflow_kwargs['schedule']}"
 
         workflow_processed_schema = {
             'workflow': deepcopy(workflow_kwargs),
diff --git a/rest/tests/workflow/create_workflow_request_model.py b/rest/tests/workflow/create_workflow_request_model.py
index 3f190575..e95fbde9 100644
--- a/rest/tests/workflow/create_workflow_request_model.py
+++ b/rest/tests/workflow/create_workflow_request_model.py
@@ -2,7 +2,7 @@
 
 workflow_request_model = {
     "workflow": {
-        "schedule_interval": "none",
+        "schedule": "none",
         "name": "WorkflowTest",
         "select_end_date": "never",
         "start_date": str(datetime.utcnow().date())
diff --git a/rest/tests/workflow/test_workflow_router.py b/rest/tests/workflow/test_workflow_router.py
index 46dc8146..b7d9b47d 100644
--- a/rest/tests/workflow/test_workflow_router.py
+++ b/rest/tests/workflow/test_workflow_router.py
@@ -33,7 +33,7 @@ def test_create_workflow(patch_piece_secret: Response, create_workflow: Response
                     "name": workflow_request_model["workflow"]["name"],
                     "start_date": workflow_request_model["workflow"]["start_date"],
                     "end_date": None,
-                    "schedule_interval": None,
+                    "schedule": None,
                     "catchup": False,
                     "generate_report": False,
                     "description": None
diff --git a/src/domino/VERSION b/src/domino/VERSION
index b35b9dd0..89235c0b 100644
--- a/src/domino/VERSION
+++ b/src/domino/VERSION
@@ -1 +1 @@
-0.5.8
\ No newline at end of file
+0.5.9
\ No newline at end of file
diff --git a/src/domino/cli/utils/platform.py b/src/domino/cli/utils/platform.py
index 9fe9d157..7238926e 100644
--- a/src/domino/cli/utils/platform.py
+++ b/src/domino/cli/utils/platform.py
@@ -15,6 +15,7 @@
 from kubernetes import client, config
 
 from domino.cli.utils.constants import COLOR_PALETTE, DOMINO_HELM_PATH, DOMINO_HELM_VERSION, DOMINO_HELM_REPOSITORY
+import shutil
 
 
 class AsLiteral(str):
@@ -660,21 +661,23 @@ def run_platform_compose(detached: bool = False, use_config_file: bool = False,
     local_path = Path(".").resolve()
     domino_dir = local_path / "domino_data"
     domino_dir.mkdir(parents=True, exist_ok=True)
-    subprocess.run(["chmod", "-R", "777", "domino_data"])
-    airflow_logs_dir = local_path / "airflow/logs"
+    domino_dir.chmod(0o777)
+
+    airflow_base = local_path / 'airflow'
+    airflow_logs_dir = airflow_base / "logs"
     airflow_logs_dir.mkdir(parents=True, exist_ok=True)
-    airflow_dags_dir = local_path / "airflow/dags"
+    airflow_dags_dir = airflow_base / "dags"
     airflow_dags_dir.mkdir(parents=True, exist_ok=True)
-    airflow_plugins_dir = local_path / "airflow/plugins"
+    airflow_plugins_dir = airflow_base / "plugins"
     airflow_plugins_dir.mkdir(parents=True, exist_ok=True)
-    subprocess.run(["chmod", "-R", "777", "airflow"])    
+    airflow_base.chmod(0o777)
 
     # Copy docker-compose.yaml file from package to local path
     if create_database:
         docker_compose_path = Path(__file__).resolve().parent / "docker-compose.yaml"
     else:
         docker_compose_path = Path(__file__).resolve().parent / "docker-compose-without-database.yaml"
-    subprocess.run(["cp", str(docker_compose_path), "./docker-compose.yaml"])
+    shutil.copy(str(docker_compose_path), "./docker-compose.yaml")
     # Run docker-compose up
     cmd = [
         "docker",