diff --git a/src/DynamoCoreWpf/DynamoCoreWpf.csproj b/src/DynamoCoreWpf/DynamoCoreWpf.csproj
index 5de998ab136..22268a6b374 100644
--- a/src/DynamoCoreWpf/DynamoCoreWpf.csproj
+++ b/src/DynamoCoreWpf/DynamoCoreWpf.csproj
@@ -223,6 +223,7 @@
     <Compile Include="Utilities\CrashUtilities.cs" />
     <Compile Include="Utilities\LibraryDragAndDrop.cs" />
     <Compile Include="Utilities\MessageBoxUtilities.cs" />
+    <Compile Include="Utilities\NodeContextMenuBuilder.cs" />
     <Compile Include="Utilities\OnceDisposable.cs" />
     <Compile Include="TestInfrastructure\ConnectorMutator.cs" />
     <Compile Include="TestInfrastructure\MutationTestAttribute.cs" />
diff --git a/src/DynamoCoreWpf/NodeViewCustomization/NodeViewCustomizations/FunctionNodeViewCustomization.cs b/src/DynamoCoreWpf/NodeViewCustomization/NodeViewCustomizations/FunctionNodeViewCustomization.cs
index aeb01b0797e..d849381a392 100644
--- a/src/DynamoCoreWpf/NodeViewCustomization/NodeViewCustomizations/FunctionNodeViewCustomization.cs
+++ b/src/DynamoCoreWpf/NodeViewCustomization/NodeViewCustomizations/FunctionNodeViewCustomization.cs
@@ -19,8 +19,6 @@ public void CustomizeView(Function function, NodeView nodeView)
             functionNodeModel = function;
             dynamoViewModel = nodeView.ViewModel.DynamoViewModel;
 
-            nodeView.MainContextMenu.Items.Add(new Separator());
-
             // edit contents
             var editItem = new MenuItem
             {
diff --git a/src/DynamoCoreWpf/Utilities/NodeContextMenuBuilder.cs b/src/DynamoCoreWpf/Utilities/NodeContextMenuBuilder.cs
new file mode 100644
index 00000000000..ab079f433ff
--- /dev/null
+++ b/src/DynamoCoreWpf/Utilities/NodeContextMenuBuilder.cs
@@ -0,0 +1,453 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using Dynamo.Controls;
+using Dynamo.Graph.Nodes;
+using Dynamo.ViewModels;
+
+namespace Dynamo.Wpf.Utilities
+{
+    /// <summary>
+    /// A static class containing methods for dynamically building a Node's Context Menu.
+    /// </summary>
+    internal static class NodeContextMenuBuilder
+    {
+        /// <summary>
+        /// A reference to the NodeViewModel whose ContextMenu is being built.
+        /// </summary>
+        internal static NodeViewModel NodeViewModel { get; set; }
+
+        /// <summary>
+        /// A reference to the ContextMenu to which items are being added. 
+        /// </summary>
+        internal static ContextMenu ContextMenu { get; set; }
+
+        // Builds the node's Context Menu, including re-adding any injected MenuItems from
+        // the NodeViewCustomization process.
+        internal static void Build(ContextMenu contextMenu, NodeViewModel nodeViewModel, OrderedDictionary nodeViewCustomizationMenuItems)
+        {
+            ContextMenu = contextMenu;
+            NodeViewModel = nodeViewModel;
+            
+            AddContextMenuItem(BuildDeleteMenuItem());
+            AddContextMenuItem(BuildGroupsMenuItem());
+            if (nodeViewModel.ShowsVisibilityToggles) AddContextMenuItem(BuildPreviewMenuItem());
+            AddContextMenuItem(BuildFreezeMenuItem());
+            AddContextMenuItem(BuildShowLabelsMenuItem());
+            AddContextMenuItem(BuildRenameMenuItem());
+            if (nodeViewModel.ArgumentLacing != LacingStrategy.Disabled) AddContextMenuItem(BuildLacingMenuItem());
+            
+            //AddContextMenuItem(BuildDismissedAlertsMenuItem());
+            
+            if (nodeViewCustomizationMenuItems.Count > 0)
+            {
+                AddContextMenuSeparator();
+                AddInjectedNodeViewCustomizationMenuItems(nodeViewCustomizationMenuItems);
+            }
+            
+            if(NodeViewModel.IsInput || NodeViewModel.IsOutput) AddContextMenuSeparator();
+            if(NodeViewModel.IsInput) AddContextMenuItem(BuildIsInputMenuItem());
+            if(NodeViewModel.IsOutput) AddContextMenuItem(BuildIsOutputMenuItem());
+
+            AddContextMenuSeparator();
+            AddContextMenuItem(BuildHelpMenuItem());
+        }
+
+        /// <summary>
+        /// Adds items to a context menu.
+        /// </summary>
+        /// <param name="menuItem"></param>
+        internal static void AddContextMenuItem(MenuItem menuItem) => ContextMenu.Items.Add(menuItem);
+
+        /// <summary>
+        /// Adds a new separator a context menu.
+        /// </summary>
+        internal static void AddContextMenuSeparator() => ContextMenu.Items.Add(new Separator());
+
+        /// <summary>
+        /// Creates a new MenuItem in the node's Context Menu.
+        /// Using optional named arguments here as it makes the Binding syntax
+        /// much cleaner if all handled in the method body.
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="header"></param>
+        /// <param name="command"></param>
+        /// <param name="commandParameter"></param>
+        /// <param name="isCheckable"></param>
+        /// <param name="isChecked"></param>
+        /// <param name="visibility"></param>
+        /// <param name="isEnabled"></param>
+        /// <returns></returns>
+        internal static MenuItem CreateMenuItem
+        (
+            string name = null,
+            string header = null,
+            Binding command = null,
+            string commandParameter = null,
+            bool isCheckable = false,
+            Binding isChecked = null,
+            Binding visibility = null,
+            Binding isEnabled = null,
+            Binding itemsSource = null
+        )
+        {
+            MenuItem menuItem = new MenuItem { Header = header, IsCheckable = isCheckable };
+
+            if (!string.IsNullOrWhiteSpace(name)) menuItem.Name = name;
+            if (command != null) menuItem.SetBinding(MenuItem.CommandProperty, command);
+            if (commandParameter != null) menuItem.CommandParameter = commandParameter;
+            if (isChecked != null) menuItem.SetBinding(MenuItem.IsCheckedProperty, isChecked);
+            if (visibility != null) menuItem.SetBinding(UIElement.VisibilityProperty, visibility);
+            if (isEnabled != null) menuItem.SetBinding(UIElement.IsEnabledProperty, isEnabled);
+            if (itemsSource != null) menuItem.SetBinding(ItemsControl.ItemsSourceProperty, itemsSource);
+
+            return menuItem;
+        }
+
+        internal static MenuItem BuildDeleteMenuItem()
+        {
+            return CreateMenuItem
+            (
+                name: "deleteElem_cm",
+                header: Properties.Resources.ContextMenuDelete,
+                command: new Binding
+                {
+                    Source = NodeViewModel,
+                    Path = new PropertyPath(nameof(NodeViewModel.DeleteCommand))
+                }
+            );
+        }
+
+        internal static MenuItem BuildGroupsMenuItem()
+        {
+            MenuItem groupsMenuItem = CreateMenuItem(header: Properties.Resources.ContextMenuGroups);
+
+            groupsMenuItem.Items.Add(CreateMenuItem
+                (
+                    name: "createGroup_cm",
+                    header: Properties.Resources.ContextCreateGroupFromSelection,
+                    command: new Binding
+                    {
+                        Source = NodeViewModel,
+                        Path = new PropertyPath(nameof(NodeViewModel.CreateGroupCommand))
+                    }
+                )
+            );
+            groupsMenuItem.Items.Add(CreateMenuItem
+                (
+                    name: "unGroup_cm",
+                    header: Properties.Resources.ContextUnGroupFromSelection,
+                    command: new Binding
+                    {
+                        Source = NodeViewModel,
+                        Path = new PropertyPath(nameof(NodeViewModel.UngroupCommand))
+                    }
+                )
+            );
+            groupsMenuItem.Items.Add(CreateMenuItem
+                (
+                    name: "addtoGroup",
+                    header: Properties.Resources.ContextAddGroupFromSelection,
+                    command: new Binding
+                    {
+                        Source = NodeViewModel,
+                        Path = new PropertyPath(nameof(NodeViewModel.AddToGroupCommand))
+                    }
+                )
+            );
+
+            return groupsMenuItem;
+        }
+
+        internal static MenuItem BuildPreviewMenuItem()
+        {
+            MenuItem previewMenuItem = CreateMenuItem
+            (
+                name: "isVisible_cm",
+                header: Properties.Resources.NodeContextMenuPreview,
+                command: new Binding
+                {
+                    Source = NodeViewModel,
+                    Path = new PropertyPath(nameof(NodeViewModel.ToggleIsVisibleCommand))
+                },
+                isCheckable: true,
+                isChecked: new Binding
+                {
+                    Source = NodeViewModel,
+                    Path = new PropertyPath(nameof(NodeViewModel.IsVisible)),
+                    Mode = BindingMode.OneWay
+                }
+            );
+
+            return previewMenuItem;
+        }
+
+        internal static MenuItem BuildFreezeMenuItem()
+        {
+            MenuItem freezeMenuItem = CreateMenuItem
+            (
+                name: "nodeIsFrozen",
+                header: Properties.Resources.NodesRunStatus,
+                command: new Binding
+                {
+                    Source = NodeViewModel,
+                    Path = new PropertyPath(nameof(NodeViewModel.ToggleIsFrozenCommand))
+                },
+                isCheckable: true,
+                isChecked: new Binding
+                {
+                    Source = NodeViewModel,
+                    Path = new PropertyPath(nameof(NodeViewModel.IsFrozenExplicitly)),
+                    Mode = BindingMode.OneWay
+                },
+                isEnabled: new Binding
+                {
+                    Source = NodeViewModel,
+                    Path = new PropertyPath(nameof(NodeViewModel.CanToggleFrozen)),
+                    Mode = BindingMode.OneWay
+                }
+            );
+
+            return freezeMenuItem;
+        }
+
+        internal static MenuItem BuildShowLabelsMenuItem()
+        {
+            MenuItem showLabelsMenuItem = CreateMenuItem
+            (
+                name: "isDisplayLabelsEnabled_cm",
+                header: Properties.Resources.NodeContextMenuShowLabels,
+                isCheckable: true,
+                isChecked: new Binding
+                {
+                    Source = NodeViewModel,
+                    Path = new PropertyPath(nameof(NodeViewModel.IsDisplayingLabels)),
+                    Mode = BindingMode.TwoWay
+                },
+                isEnabled: new Binding
+                {
+                    Source = NodeViewModel,
+                    Path = new PropertyPath(nameof(NodeViewModel.CanDisplayLabels))
+                }
+            );
+
+            return showLabelsMenuItem;
+        }
+
+        internal static MenuItem BuildRenameMenuItem()
+        {
+            MenuItem renameMenuItem = CreateMenuItem
+            (
+                name: "rename_cm",
+                header: Properties.Resources.NodeContextMenuRenameNode,
+                command: new Binding
+                {
+                    Source = NodeViewModel,
+                    Path = new PropertyPath(nameof(NodeViewModel.RenameCommand))
+                }
+            );
+            return renameMenuItem;
+        }
+
+        internal static MenuItem BuildLacingMenuItem()
+        {
+            MenuItem lacingMenuItem = CreateMenuItem(header: Properties.Resources.ContextMenuLacing);
+
+            lacingMenuItem.Items.Add(CreateMenuItem
+            (
+                header: Properties.Resources.ContextMenuLacingAuto,
+                command: new Binding
+                {
+                    Source = NodeViewModel,
+                    Path = new PropertyPath(nameof(NodeViewModel.SetLacingTypeCommand)),
+                },
+                commandParameter: "Auto",
+                isCheckable: true,
+                isChecked: new Binding
+                {
+                    Source = NodeViewModel,
+                    Path = new PropertyPath(nameof(NodeViewModel.ArgumentLacing)),
+                    Converter = new EnumToBooleanConverter(),
+                    ConverterParameter = "Auto",
+                    Mode = BindingMode.OneWay
+                }
+            ));
+
+            lacingMenuItem.Items.Add(CreateMenuItem
+            (
+                header: Properties.Resources.ContextMenuLacingShortest,
+                command: new Binding
+                {
+                    Source = NodeViewModel,
+                    Path = new PropertyPath(nameof(NodeViewModel.SetLacingTypeCommand)),
+                },
+                commandParameter: "Shortest",
+                isCheckable: true,
+                isChecked: new Binding
+                {
+                    Source = NodeViewModel,
+                    Path = new PropertyPath(nameof(NodeViewModel.ArgumentLacing)),
+                    Converter = new EnumToBooleanConverter(),
+                    ConverterParameter = "Shortest",
+                    Mode = BindingMode.OneWay
+                }
+                ));
+
+            lacingMenuItem.Items.Add(CreateMenuItem
+            (
+                header: Properties.Resources.ContextMenuLacingLongest,
+                command: new Binding
+                {
+                    Source = NodeViewModel,
+                    Path = new PropertyPath(nameof(NodeViewModel.SetLacingTypeCommand)),
+                },
+                commandParameter: "Longest",
+                isCheckable: true,
+                isChecked: new Binding
+                {
+                    Source = NodeViewModel,
+                    Path = new PropertyPath(nameof(NodeViewModel.ArgumentLacing)),
+                    Converter = new EnumToBooleanConverter(),
+                    ConverterParameter = "Longest",
+                    Mode = BindingMode.OneWay
+                }
+            ));
+
+            lacingMenuItem.Items.Add(CreateMenuItem
+            (
+                header: Properties.Resources.ContextMenuLacingCrossProduct,
+                command: new Binding
+                {
+                    Source = NodeViewModel,
+                    Path = new PropertyPath(nameof(NodeViewModel.SetLacingTypeCommand)),
+                },
+                commandParameter: "CrossProduct",
+                isCheckable: true,
+                isChecked: new Binding
+                {
+                    Source = NodeViewModel,
+                    Path = new PropertyPath(nameof(NodeViewModel.ArgumentLacing)),
+                    Converter = new EnumToBooleanConverter(),
+                    ConverterParameter = "CrossProduct",
+                    Mode = BindingMode.OneWay
+                }
+            ));
+
+            return lacingMenuItem;
+        }
+
+        // To be connected in a future PR for Node Info States.
+        private static MenuItem BuildDismissedAlertsMenuItem()
+        {
+            //MenuItem dismissedAlertsMenuItem = CreateMenuItem
+            //(
+            //    name: "dismissedAlerts",
+            //    header: Wpf.Properties.Resources.NodeInformationalStateDismissedAlerts,
+            //    itemsSource: new Binding
+            //    {
+            //        Source = viewModel,
+            //        Path = new PropertyPath(nameof("DismissedAlerts"),
+            //        UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged
+            //    }
+            //);
+            //DataTemplate itemTemplate = new DataTemplate(typeof(MenuItem));
+
+            //FrameworkElementFactory grid = new FrameworkElementFactory(typeof(Grid));
+            //grid.Name = "mainTemplateGrid";
+            //grid.SetValue(WidthProperty, 220.0);
+            //grid.SetValue(HeightProperty, 30.0);
+            //grid.SetValue(MarginProperty, new Thickness(-15,0,0,0));
+            //grid.SetValue(HorizontalAlignmentProperty, HorizontalAlignment.Left);
+            //grid.SetValue(VerticalAlignmentProperty, VerticalAlignment.Stretch);
+            //grid.SetValue(BackgroundProperty, new SolidColorBrush(Colors.Transparent));
+
+            //FrameworkElementFactory textBlock = new FrameworkElementFactory(typeof(TextBlock));
+            //textBlock.SetValue(HorizontalAlignmentProperty, HorizontalAlignment.Stretch);
+            //textBlock.SetValue(MarginProperty, new Thickness(15, 0, 0, 0));
+            //textBlock.SetValue(IsHitTestVisibleProperty, false);
+            //textBlock.SetValue(VerticalAlignmentProperty, VerticalAlignment.Center);
+            //textBlock.SetValue(ForegroundProperty, new SolidColorBrush(Color.FromRgb(238,238,238)));
+
+            //dismissedAlertsMenuItem.ItemTemplate = itemTemplate;
+
+            //AddContextMenuItem(dismissedAlertsMenuItem, insertionPoint++);
+
+            return null;
+        }
+
+        internal static void AddInjectedNodeViewCustomizationMenuItems(OrderedDictionary nodeViewCustomizationMenuItems)
+        {
+            foreach (DictionaryEntry keyValuePair in nodeViewCustomizationMenuItems)
+            {
+                ContextMenu.Items.Add(keyValuePair.Value);
+            }
+        }
+
+        internal static MenuItem BuildIsInputMenuItem()
+        {
+            return CreateMenuItem
+            (
+                name: "isInput_cm",
+                header: Properties.Resources.NodeContextMenuIsInput,
+                isCheckable: true,
+                isChecked: new Binding
+                {
+                    Source = NodeViewModel,
+                    Path = new PropertyPath(nameof(NodeViewModel.IsSetAsInput)),
+                    Mode = BindingMode.TwoWay,
+                }
+            );
+        }
+
+        internal static MenuItem BuildIsOutputMenuItem()
+        {
+            return CreateMenuItem
+            (
+                name: "isOutput_cm",
+                header: Properties.Resources.NodeContextMenuIsOutput,
+                isCheckable: true,
+                isChecked: new Binding
+                {
+                    Source = NodeViewModel,
+                    Path = new PropertyPath(nameof(NodeViewModel.IsSetAsOutput)),
+                    Mode = BindingMode.TwoWay,
+                }
+            );
+        }
+
+        internal static MenuItem BuildHelpMenuItem()
+        {
+            return CreateMenuItem
+            (
+                name: "help_cm",
+                header: Properties.Resources.NodeContextMenuHelp,
+                command: new Binding
+                {
+                    Source = NodeViewModel,
+                    Path = new PropertyPath(nameof(NodeViewModel.ShowHelpCommand))
+                }
+            );
+        }
+
+        /// <summary>
+        /// A list of the names of nodes' default menu items, which cannot be dynamically injected into its context menu.
+        /// </summary>
+        internal static readonly List<string> NodeContextMenuDefaultItemNames = new List<string>
+        {
+            Properties.Resources.ContextMenuDelete,
+            Properties.Resources.ContextMenuGroups,
+            Properties.Resources.NodeContextMenuPreview,
+            Properties.Resources.NodesRunStatus,
+            Properties.Resources.NodeContextMenuShowLabels,
+            Properties.Resources.NodeContextMenuRenameNode,
+            Properties.Resources.ContextMenuLacing,
+            //Wpf.Properties.Resources.NodeInformationalStateDismissedAlerts,
+            Properties.Resources.NodeContextMenuIsInput,
+            Properties.Resources.NodeContextMenuIsOutput,
+            Properties.Resources.NodeContextMenuHelp
+        };
+    }
+}
diff --git a/src/DynamoCoreWpf/ViewModels/Core/NodeViewModel.cs b/src/DynamoCoreWpf/ViewModels/Core/NodeViewModel.cs
index 33dbf032e71..68d54466b42 100644
--- a/src/DynamoCoreWpf/ViewModels/Core/NodeViewModel.cs
+++ b/src/DynamoCoreWpf/ViewModels/Core/NodeViewModel.cs
@@ -203,12 +203,7 @@ public bool IsSetAsOutput
             }
         }
 
-        /// <summary>
-        /// Used to determine whether the node's context menu display an Output/Input menu
-        /// </summary>
-        [JsonIgnore]
-        public bool IsInputOrOutput => IsInput || IsOutput;
-
+        
         /// <summary>
         /// The Name of the nodemodel this view points to
         /// this is the name of the node as it is displayed in the UI.
@@ -283,7 +278,7 @@ public bool IsCustomFunction
         {
             get { return nodeLogic.IsCustomFunction ? true : false; }
         }
-
+        
         /// <summary>
         /// Element's left position is two-way bound to this value
         /// </summary>
diff --git a/src/DynamoCoreWpf/Views/Core/NodeView.xaml b/src/DynamoCoreWpf/Views/Core/NodeView.xaml
index d9564016027..9676379602a 100644
--- a/src/DynamoCoreWpf/Views/Core/NodeView.xaml
+++ b/src/DynamoCoreWpf/Views/Core/NodeView.xaml
@@ -13,7 +13,7 @@
              MouseEnter="OnNodeViewMouseEnter"
              MouseLeave="OnNodeViewMouseLeave"
              MouseLeftButtonDown="topControl_MouseLeftButtonDown"
-             MouseRightButtonDown="topControl_MouseRightButtonDown"
+             MouseRightButtonDown="DisplayNodeContextMenu"
              PreviewMouseLeftButtonDown="OnPreviewMouseLeftButtonDown"
              PreviewMouseMove="OnNodeViewMouseMove">
 
@@ -47,7 +47,10 @@
 
         <!--  CONTEXT MENU  -->
         <Grid.ContextMenu>
-            <ContextMenu Name="MainContextMenu" x:FieldModifier="public">
+            <ContextMenu Name="MainContextMenu"
+                         x:FieldModifier="public"
+                         Closed="MainContextMenu_OnClosed"
+                         Style="{StaticResource ContextMenuStyle}">
                 <ContextMenu.Resources>
                     <ResourceDictionary>
                         <ResourceDictionary.MergedDictionaries>
@@ -190,108 +193,6 @@
                         </Style>
                     </ResourceDictionary>
                 </ContextMenu.Resources>
-                <MenuItem Name="deleteElem_cm"
-                          Command="{Binding Path=DeleteCommand}"
-                          Header="{x:Static p:Resources.ContextMenuDelete}"
-                          IsCheckable="False" />
-                <MenuItem Header="{x:Static p:Resources.ContextMenuGroups}" IsCheckable="False">
-                    <MenuItem Name="createGroup_cm"
-                              Command="{Binding Path=CreateGroupCommand}"
-                              Header="{x:Static p:Resources.ContextCreateGroupFromSelection}" />
-                    <MenuItem Name="unGroup_cm"
-                              Command="{Binding Path=UngroupCommand}"
-                              Header="{x:Static p:Resources.ContextUnGroupFromSelection}" />
-                    <MenuItem Name="addtoGroup"
-                              Command="{Binding Path=AddToGroupCommand}"
-                              Header="{x:Static p:Resources.ContextAddGroupFromSelection}" />
-                </MenuItem>
-                <MenuItem Name="isVisible_cm"
-                          Command="{Binding Path=ToggleIsVisibleCommand}"
-                          Header="{x:Static p:Resources.NodeContextMenuPreview}"
-                          IsCheckable="True"
-                          IsChecked="{Binding Path=IsVisible, Mode=OneWay}"
-                          Visibility="{Binding Path=ShowsVisibilityToggles, Converter={StaticResource BooleanToVisibilityCollapsedConverter}}" />
-                <MenuItem Name="nodeIsFrozen"
-                          Command="{Binding Path=ToggleIsFrozenCommand}"
-                          Header="{x:Static p:Resources.NodesRunStatus}"
-                          IsCheckable="True"
-                          IsChecked="{Binding IsFrozenExplicitly, Mode=OneWay}"
-                          IsEnabled="{Binding CanToggleFrozen, Mode=OneWay}" />
-                <MenuItem Name="isDisplayLabelsEnabled_cm"
-                          Header="{x:Static p:Resources.NodeContextMenuShowLabels}"
-                          IsCheckable="True"
-                          IsChecked="{Binding Path=IsDisplayingLabels, Mode=TwoWay}"
-                          IsEnabled="{Binding Path=CanDisplayLabels}" />
-                <MenuItem Name="rename_cm"
-                          Command="{Binding Path=RenameCommand}"
-                          Header="{x:Static p:Resources.NodeContextMenuRenameNode}"
-                          IsCheckable="False" />
-                <MenuItem Header="{x:Static p:Resources.ContextMenuLacing}"
-                          IsCheckable="False"
-                          Visibility="{Binding Path=ArgumentLacing, Converter={StaticResource LacingToVisibilityConverter}, Mode=OneWay}">
-                    <MenuItem Command="{Binding Path=SetLacingTypeCommand}"
-                              CommandParameter="Auto"
-                              Header="{x:Static p:Resources.ContextMenuLacingAuto}"
-                              IsCheckable="True"
-                              IsChecked="{Binding Path=ArgumentLacing, Converter={StaticResource EnumToBoolConverter}, ConverterParameter=Auto, Mode=OneWay}" />
-                    <MenuItem Command="{Binding Path=SetLacingTypeCommand}"
-                              CommandParameter="Shortest"
-                              Header="{x:Static p:Resources.ContextMenuLacingShortest}"
-                              IsCheckable="True"
-                              IsChecked="{Binding Path=ArgumentLacing, Converter={StaticResource EnumToBoolConverter}, ConverterParameter=Shortest, Mode=OneWay}" />
-                    <MenuItem Command="{Binding Path=SetLacingTypeCommand}"
-                              CommandParameter="Longest"
-                              Header="{x:Static p:Resources.ContextMenuLacingLongest}"
-                              IsCheckable="True"
-                              IsChecked="{Binding Path=ArgumentLacing, Converter={StaticResource EnumToBoolConverter}, ConverterParameter=Longest, Mode=OneWay}" />
-                    <MenuItem Command="{Binding Path=SetLacingTypeCommand}"
-                              CommandParameter="CrossProduct"
-                              Header="{x:Static p:Resources.ContextMenuLacingCrossProduct}"
-                              IsCheckable="True"
-                              IsChecked="{Binding Path=ArgumentLacing, Converter={StaticResource EnumToBoolConverter}, ConverterParameter=CrossProduct, Mode=OneWay}" />
-                </MenuItem>
-                <MenuItem Name="dismissedAlerts" Header="Dismissed Alerts" />
-                <Separator Visibility="{Binding Path=IsInputOrOutput, Converter={StaticResource BooleanToVisibilityCollapsedConverter}}"/>
-                <MenuItem Name="isInput_cm"
-                          Header="{x:Static p:Resources.NodeContextMenuIsInput}"
-                          IsCheckable="True"
-                          IsChecked="{Binding Path=IsSetAsInput, Mode=TwoWay}"
-                          Visibility="{Binding Path=IsInput, Converter={StaticResource BooleanToVisibilityCollapsedConverter}}" />
-                <MenuItem Name="isOutput_cm"
-                          Header="{x:Static p:Resources.NodeContextMenuIsOutput}"
-                          IsCheckable="True"
-                          IsChecked="{Binding Path=IsSetAsOutput, Mode=TwoWay}"
-                          Visibility="{Binding Path=IsOutput, Converter={StaticResource BooleanToVisibilityCollapsedConverter}}" />
-                <Separator />
-                <MenuItem Name="help_cm"
-                          Command="{Binding Path=ShowHelpCommand}"
-                          Header="{x:Static p:Resources.NodeContextMenuHelp}"
-                          IsCheckable="False" />
-                <ContextMenu.Style>
-                    <Style TargetType="{x:Type ContextMenu}">
-                        <Setter Property="Placement" Value="MousePoint" />
-                        <Setter Property="Foreground" Value="{StaticResource NodeContextMenuForeground}" />
-                        <Setter Property="FontSize" Value="13px" />
-                        <Setter Property="FontFamily" Value="{StaticResource ArtifaktElementRegular}" />
-                        <Setter Property="FontWeight" Value="Medium" />
-                        <Setter Property="SnapsToDevicePixels" Value="True" />
-                        <Setter Property="OverridesDefaultStyle" Value="True" />
-                        <Setter Property="Template">
-                            <Setter.Value>
-                                <ControlTemplate TargetType="{x:Type ContextMenu}">
-                                    <Border x:Name="Border"
-                                            Background="{StaticResource NodeContextMenuBackground}"
-                                            BorderThickness="0px">
-                                        <StackPanel Margin="0,10"
-                                                    ClipToBounds="True"
-                                                    IsItemsHost="True"
-                                                    Orientation="Vertical" />
-                                    </Border>
-                                </ControlTemplate>
-                            </Setter.Value>
-                        </Setter>
-                    </Style>
-                </ContextMenu.Style>
             </ContextMenu>
         </Grid.ContextMenu>
 
@@ -560,7 +461,7 @@
                 </Grid.Style>
             </Grid>
             <Button x:Name="OptionsButton"
-                    Click="OptionsButton_Click"
+                    Click="DisplayNodeContextMenu"
                     ToolTip="{x:Static p:Resources.ContextMenu}">
                 <Button.Style>
                     <Style TargetType="{x:Type Button}">
@@ -694,4 +595,4 @@
             <Label HorizontalContentAlignment="Center" Content="{Binding ASTText}" />
         </Canvas>
     </Grid>
-</UserControl>
+</UserControl>
\ No newline at end of file
diff --git a/src/DynamoCoreWpf/Views/Core/NodeView.xaml.cs b/src/DynamoCoreWpf/Views/Core/NodeView.xaml.cs
index 395a7656c57..a9d735a1554 100644
--- a/src/DynamoCoreWpf/Views/Core/NodeView.xaml.cs
+++ b/src/DynamoCoreWpf/Views/Core/NodeView.xaml.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.Specialized;
 using System.Diagnostics;
 using System.Windows;
 using System.Windows.Controls;
@@ -16,6 +17,7 @@
 using Dynamo.UI.Prompts;
 using Dynamo.Utilities;
 using Dynamo.ViewModels;
+using Dynamo.Wpf.Utilities;
 using DynCmd = Dynamo.Models.DynamoModel;
 
 
@@ -61,13 +63,13 @@ private set
                 if (viewModel.PreviewPinned)
                 {
                     CreatePreview(viewModel);
-                }                
+                }
             }
         }
 
         private void NodeView_MouseLeave(object sender, MouseEventArgs e)
         {
-            if (viewModel!=null && viewModel.OnMouseLeave != null)
+            if (viewModel != null && viewModel.OnMouseLeave != null)
                 viewModel.OnMouseLeave();
         }
 
@@ -427,7 +429,7 @@ private void topControl_MouseLeftButtonDown(object sender, MouseButtonEventArgs
                 }
             }
         }
-        
+
         private void NameBlock_OnMouseDown(object sender, MouseButtonEventArgs e)
         {
             if (e.ClickCount == 2)
@@ -679,7 +681,8 @@ internal void TogglePreviewControlAllowance()
                 {
                     PreviewControl.TransitionToState(PreviewControl.State.Condensed);
                     PreviewControl.TransitionToState(PreviewControl.State.Hidden);
-                } else if (PreviewControl.IsCondensed)
+                }
+                else if (PreviewControl.IsCondensed)
                 {
                     PreviewControl.TransitionToState(PreviewControl.State.Hidden);
                 }
@@ -688,28 +691,64 @@ internal void TogglePreviewControlAllowance()
 
         #endregion
 
-        private void OptionsButton_Click(object sender, RoutedEventArgs e)
+        /// <summary>
+        /// A dictionary of MenuItems which are added during certain nodes' NodeViewCustomization process.
+        /// </summary>
+        private OrderedDictionary NodeViewCustomizationMenuItems { get; } = new OrderedDictionary();
+
+        /// <summary>
+        /// Saves a persistent list of unique MenuItems that are added by certain nodes during their NodeViewCustomization process.
+        /// Because nodes' ContextMenus are loaded lazily, and their MenuItems are disposed on closing,
+        /// these custom MenuItems need to be manually re-injected into the context menu whenever it is opened.
+        /// </summary>
+        private void StashNodeViewCustomizationMenuItems()
         {
-            Guid nodeGuid = ViewModel.NodeModel.GUID;
-            ViewModel.DynamoViewModel.ExecuteCommand(
-                new DynCmd.SelectModelCommand(nodeGuid, Keyboard.Modifiers.AsDynamoType()));
+            foreach (var obj in grid.ContextMenu.Items)
+            {
+                if (!(obj is MenuItem menuItem)) continue;
 
-            viewModel.OnSelected(this, EventArgs.Empty);
-            grid.ContextMenu.DataContext = viewModel;
-            grid.ContextMenu.IsOpen = true;
+                // We don't stash default MenuItems, such as 'Freeze'.
+                if (NodeContextMenuBuilder.NodeContextMenuDefaultItemNames.Contains(menuItem.Header.ToString())) continue;
+
+                // We don't stash the same MenuItem multiple times.
+                if (NodeViewCustomizationMenuItems.Contains(menuItem.Header.ToString())) continue;
+                
+                // The MenuItem gets stashed.
+                NodeViewCustomizationMenuItems.Add(menuItem.Header.ToString(), menuItem);
+            }
         }
 
-        private void topControl_MouseRightButtonDown(object sender, MouseButtonEventArgs e)
+        /// <summary>
+        /// A common method to handle the node Options Button being clicked and
+        /// the user right-clicking on the node body to open its ContextMenu.
+        /// </summary>
+        private void DisplayNodeContextMenu(object sender, RoutedEventArgs e)
         {
             Guid nodeGuid = ViewModel.NodeModel.GUID;
             ViewModel.DynamoViewModel.ExecuteCommand(
                 new DynCmd.SelectModelCommand(nodeGuid, Keyboard.Modifiers.AsDynamoType()));
 
-            viewModel.OnSelected(this, EventArgs.Empty);
+            var contextMenu = grid.ContextMenu;
 
-            grid.ContextMenu.DataContext = viewModel;
-            grid.ContextMenu.IsOpen = true;
+            // Stashing any injected MenuItems from the Node View Customization process.
+            if (contextMenu.Items.Count > 0 && NodeViewCustomizationMenuItems.Count < 1)
+            {
+                StashNodeViewCustomizationMenuItems();
+            }
+
+            // Clearing any existing items in the node's ContextMenu.
+            contextMenu.Items.Clear();
+            NodeContextMenuBuilder.Build(contextMenu, viewModel, NodeViewCustomizationMenuItems);
             
+            contextMenu.DataContext = viewModel;
+            contextMenu.IsOpen = true;
+
+            e.Handled = true;
+        }
+
+        private void MainContextMenu_OnClosed(object sender, RoutedEventArgs e)
+        {
+            grid.ContextMenu.Items.Clear();
             e.Handled = true;
         }
     }
diff --git a/src/Libraries/PythonNodeModelsWpf/PythonNode.cs b/src/Libraries/PythonNodeModelsWpf/PythonNode.cs
index 0d64108b609..863e5001823 100644
--- a/src/Libraries/PythonNodeModelsWpf/PythonNode.cs
+++ b/src/Libraries/PythonNodeModelsWpf/PythonNode.cs
@@ -36,13 +36,11 @@ public void CustomizeView(PythonNode nodeModel, NodeView nodeView)
             dynamoViewModel = nodeView.ViewModel.DynamoViewModel;
             workspaceModel = nodeView.ViewModel.WorkspaceViewModel.Model;
 
-            Separator separator = new Separator();
-            nodeView.MainContextMenu.Items.Insert(8, separator);
-            nodeView.MainContextMenu.Items.Insert(9, editWindowItem);
+            nodeView.MainContextMenu.Items.Add(editWindowItem);
             editWindowItem.Click += EditScriptContent;
 
             var pythonEngineVersionMenu = new MenuItem { Header = PythonNodeModels.Properties.Resources.PythonNodeContextMenuEngineSwitcher, IsCheckable = false };
-            nodeView.MainContextMenu.Items.Insert(10, pythonEngineVersionMenu);
+            nodeView.MainContextMenu.Items.Add(pythonEngineVersionMenu);
             pythonEngine2Item.Click += UpdateToPython2Engine;
             // Bind menu item check state to the Engine property in the ViewModel.
             // By doing this, we make sure the check status is in sync with the ViewModel,
@@ -65,7 +63,7 @@ public void CustomizeView(PythonNode nodeModel, NodeView nodeView)
             learnMoreItem.Click += OpenPythonLearningMaterial;
             pythonEngineVersionMenu.Items.Add(pythonEngine2Item);
             pythonEngineVersionMenu.Items.Add(pythonEngine3Item);
-            nodeView.MainContextMenu.Items.Insert(11, learnMoreItem);
+            nodeView.MainContextMenu.Items.Add(learnMoreItem);
 
             nodeView.UpdateLayout();
 
@@ -77,7 +75,7 @@ public void CustomizeView(PythonNode nodeModel, NodeView nodeView)
             Canvas.SetZIndex(engineLabel, 5);
             engineLabel.HorizontalAlignment = HorizontalAlignment.Left;
             engineLabel.VerticalAlignment = VerticalAlignment.Bottom;
-            engineLabel.Margin = new Thickness(14, -4, 0, 4);
+            engineLabel.Margin = new Thickness(14, -4, -10, 4);
             nodeView.grid.Children.Add(engineLabel);
             Grid.SetColumn(engineLabel, 0);
             Grid.SetRow(engineLabel, 3);
diff --git a/test/DynamoCoreWpfTests/DynamoCoreWpfTests.csproj b/test/DynamoCoreWpfTests/DynamoCoreWpfTests.csproj
index 753f061a32a..c659ad4ac36 100644
--- a/test/DynamoCoreWpfTests/DynamoCoreWpfTests.csproj
+++ b/test/DynamoCoreWpfTests/DynamoCoreWpfTests.csproj
@@ -186,6 +186,7 @@
     <Compile Include="SliderViewModelTests.cs" />
     <Compile Include="StringToDateTimeOffsetConverterTest.cs" />
     <Compile Include="Utility\DispatcherUtil.cs" />
+    <Compile Include="Utility\NodeContextMenuBuilderTests.cs" />
     <Compile Include="Utility\ViewExtensions.cs" />
     <Compile Include="UpdateManagerUITests.cs" />
     <Compile Include="ViewExtensions\GraphMetadataViewExtensionTests.cs" />
diff --git a/test/DynamoCoreWpfTests/Utility/NodeContextMenuBuilderTests.cs b/test/DynamoCoreWpfTests/Utility/NodeContextMenuBuilderTests.cs
new file mode 100644
index 00000000000..e0fea07e96b
--- /dev/null
+++ b/test/DynamoCoreWpfTests/Utility/NodeContextMenuBuilderTests.cs
@@ -0,0 +1,220 @@
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Linq;
+using System.Windows.Controls;
+using Dynamo.Graph.Nodes;
+using Dynamo.Wpf.Utilities;
+using NUnit.Framework;
+
+namespace DynamoCoreWpfTests.Utility
+{
+    public class NodeContextMenuBuilderTests : DynamoTestUIBase
+    {
+        /// <summary>
+        /// Checks that the Build method constructs the node context menu as expected.
+        /// </summary>
+        [Test]
+        public void TestBuildContextMenu()
+        {
+            // Arrange
+            var dummyNode = new DummyNode();
+
+            ViewModel.Model.CurrentWorkspace.AddAndRegisterNode(dummyNode, false);
+
+            Assert.That(ViewModel.Model.CurrentWorkspace.Nodes.Contains(dummyNode));
+
+            var dummyNodeViewModel = ViewModel.CurrentSpaceViewModel.Nodes
+                .FirstOrDefault(x => x.Id == dummyNode.GUID);
+
+            ContextMenu contextMenu = new ContextMenu();
+
+            // Act
+            NodeContextMenuBuilder.Build
+            (
+                contextMenu,
+                dummyNodeViewModel,
+                new OrderedDictionary()
+            );
+
+            // Assert
+            List<string> menuItemNames = contextMenu.Items
+                .OfType<MenuItem>()
+                .Select(x => x.Header.ToString())
+                .ToList();
+
+            CollectionAssert.Contains(menuItemNames, Dynamo.Wpf.Properties.Resources.ContextMenuDelete);
+            CollectionAssert.Contains(menuItemNames, Dynamo.Wpf.Properties.Resources.ContextMenuGroups);
+            CollectionAssert.Contains(menuItemNames, Dynamo.Wpf.Properties.Resources.NodesRunStatus);
+            CollectionAssert.Contains(menuItemNames, Dynamo.Wpf.Properties.Resources.NodeContextMenuShowLabels);
+            CollectionAssert.Contains(menuItemNames, Dynamo.Wpf.Properties.Resources.NodeContextMenuRenameNode);
+            CollectionAssert.Contains(menuItemNames, Dynamo.Wpf.Properties.Resources.NodeContextMenuHelp);
+
+            if (dummyNodeViewModel.ShowsVisibilityToggles)
+            {
+                CollectionAssert.Contains(menuItemNames, Dynamo.Wpf.Properties.Resources.NodeContextMenuShowLabels);
+            }
+            
+            if (dummyNodeViewModel.ArgumentLacing != LacingStrategy.Disabled)
+            {
+                CollectionAssert.Contains(menuItemNames, Dynamo.Wpf.Properties.Resources.ContextMenuLacing);
+            }
+            
+            if (dummyNodeViewModel.IsInput)
+            {
+                CollectionAssert.Contains(menuItemNames, Dynamo.Wpf.Properties.Resources.NodeContextMenuIsInput);
+            }
+            
+            if (dummyNodeViewModel.IsOutput)
+            {
+                CollectionAssert.Contains(menuItemNames, Dynamo.Wpf.Properties.Resources.NodeContextMenuIsOutput);
+            }
+
+            int expectedSeparatorsCount = dummyNodeViewModel.IsInput || dummyNodeViewModel.IsOutput ? 2 : 1;
+
+            List<Separator> separators = contextMenu.Items.OfType<Separator>().ToList();
+            Assert.AreEqual(expectedSeparatorsCount, separators.Count);
+        }
+
+        /// <summary>
+        /// Checks that the NodeContextMenuItemBuilder is able to load MenuItems which come from the
+        /// NodeViewCustomization process. Builds one ContextMenu without custom items, and another with two of them.
+        /// </summary>
+        [Test]
+        public void AddNodeViewCustomizationMenuItems()
+        {
+            // Arrange
+            var dummyNode = new DummyNode();
+            var dummyNodeForCustomization = new DummyNode();
+
+            ViewModel.Model.CurrentWorkspace.AddAndRegisterNode(dummyNode, false);
+            ViewModel.Model.CurrentWorkspace.AddAndRegisterNode(dummyNodeForCustomization, false);
+
+            var dummyNodeViewModel = ViewModel.CurrentSpaceViewModel.Nodes
+                .FirstOrDefault(x => x.Id == dummyNode.GUID);
+
+            var dummyNodeForCustomizationViewModel = ViewModel.CurrentSpaceViewModel.Nodes
+                .FirstOrDefault(x => x.Id == dummyNode.GUID);
+
+            Assert.That(ViewModel.Model.CurrentWorkspace.Nodes.Contains(dummyNode));
+            Assert.That(ViewModel.Model.CurrentWorkspace.Nodes.Contains(dummyNodeForCustomization));
+
+            ContextMenu contextMenu = new ContextMenu();
+            ContextMenu contextMenuForNodeViewCustomization = new ContextMenu();
+
+            OrderedDictionary emptyDictionary = new OrderedDictionary();
+            OrderedDictionary nodeViewCustomizationMenuItems = new OrderedDictionary();
+
+            MenuItem menuItem1 = new MenuItem { Header = "TestItem1" };
+            MenuItem menuItem2 = new MenuItem { Header = "TestItem2" };
+
+            nodeViewCustomizationMenuItems.Add(menuItem1.Header, menuItem1);
+            nodeViewCustomizationMenuItems.Add(menuItem2.Header, menuItem2);
+            
+            // Act
+            NodeContextMenuBuilder.Build
+            (
+                contextMenu,
+                dummyNodeViewModel,
+                emptyDictionary
+            );
+            
+            NodeContextMenuBuilder.Build
+            (
+                contextMenuForNodeViewCustomization,
+                dummyNodeForCustomizationViewModel,
+                nodeViewCustomizationMenuItems
+            );
+
+            // Assert
+            CollectionAssert.DoesNotContain(contextMenu.Items, menuItem1);
+            CollectionAssert.Contains(contextMenuForNodeViewCustomization.Items, menuItem1);
+            CollectionAssert.DoesNotContain(contextMenu.Items, menuItem2);
+            CollectionAssert.Contains(contextMenuForNodeViewCustomization.Items, menuItem2);
+        }
+
+        /// <summary>
+        /// Tests the individual build methods that are part of the NodeContextMenuBuilder.
+        /// </summary>
+        [Test]
+        public void TestBuildMethods()
+        {
+            // Act
+            MenuItem buildDeleteMenuItem = NodeContextMenuBuilder.BuildDeleteMenuItem();
+            MenuItem buildGroupsMenuItem = NodeContextMenuBuilder.BuildGroupsMenuItem();
+            MenuItem buildPreviewMenuItem = NodeContextMenuBuilder.BuildPreviewMenuItem();
+            MenuItem buildFreezeMenuItem = NodeContextMenuBuilder.BuildFreezeMenuItem();
+            MenuItem buildShowLabelsMenuItem = NodeContextMenuBuilder.BuildShowLabelsMenuItem();
+            MenuItem buildRenameMenuItem = NodeContextMenuBuilder.BuildRenameMenuItem();
+            MenuItem buildLacingMenuItem = NodeContextMenuBuilder.BuildLacingMenuItem();
+            MenuItem buildIsInputMenuItem = NodeContextMenuBuilder.BuildIsInputMenuItem();
+            MenuItem buildIsOutputMenuItem = NodeContextMenuBuilder.BuildIsOutputMenuItem();
+            MenuItem buildHelpMenuItem = NodeContextMenuBuilder.BuildHelpMenuItem();
+            
+            // Assert
+            Assert.IsNotNull(buildDeleteMenuItem);
+            Assert.IsNotNull(buildGroupsMenuItem);
+            Assert.IsNotNull(buildPreviewMenuItem);
+            Assert.IsNotNull(buildFreezeMenuItem);
+            Assert.IsNotNull(buildShowLabelsMenuItem);
+            Assert.IsNotNull(buildRenameMenuItem);
+            Assert.IsNotNull(buildLacingMenuItem);
+            Assert.IsNotNull(buildIsInputMenuItem);
+            Assert.IsNotNull(buildIsOutputMenuItem);
+            Assert.IsNotNull(buildHelpMenuItem);
+            
+            Assert.AreEqual(Dynamo.Wpf.Properties.Resources.ContextMenuDelete, buildDeleteMenuItem.Header);
+            Assert.AreEqual(Dynamo.Wpf.Properties.Resources.ContextMenuGroups, buildGroupsMenuItem.Header);
+            Assert.AreEqual(3, buildGroupsMenuItem.Items.Count);
+            Assert.AreEqual(Dynamo.Wpf.Properties.Resources.NodeContextMenuPreview, buildPreviewMenuItem.Header);
+            Assert.AreEqual(Dynamo.Wpf.Properties.Resources.NodesRunStatus, buildFreezeMenuItem.Header);
+            Assert.AreEqual(Dynamo.Wpf.Properties.Resources.NodeContextMenuShowLabels, buildShowLabelsMenuItem.Header);
+            Assert.AreEqual(Dynamo.Wpf.Properties.Resources.NodeContextMenuRenameNode, buildRenameMenuItem.Header);
+            Assert.AreEqual(Dynamo.Wpf.Properties.Resources.ContextMenuLacing, buildLacingMenuItem.Header);
+            Assert.AreEqual(4, buildLacingMenuItem.Items.Count);
+            Assert.AreEqual(Dynamo.Wpf.Properties.Resources.NodeContextMenuIsInput, buildIsInputMenuItem.Header);
+            Assert.AreEqual(Dynamo.Wpf.Properties.Resources.NodeContextMenuIsOutput, buildIsOutputMenuItem.Header);
+            Assert.AreEqual(Dynamo.Wpf.Properties.Resources.NodeContextMenuHelp, buildHelpMenuItem.Header);
+        }
+
+        /// <summary>
+        /// Tests that the AddContextMenuItem method adds the given MenuItem to the target ContextMenu.
+        /// </summary>
+        [Test]
+        public void TestAddMenuItem()
+        {
+            // Arrange
+            ContextMenu contextMenu = new ContextMenu();
+            NodeContextMenuBuilder.ContextMenu = contextMenu;
+
+            MenuItem menuItem1 = new MenuItem { Header = "TestItem1" };
+            
+            CollectionAssert.DoesNotContain(contextMenu.Items, menuItem1);
+
+            // Act
+            NodeContextMenuBuilder.AddContextMenuItem(menuItem1);
+
+            // Assert
+            CollectionAssert.Contains(contextMenu.Items, menuItem1);
+        }
+
+        /// <summary>
+        /// Tests that the AddContextMenuSeparator method adds a new Separator to the target ContextMenu.
+        /// </summary>
+        [Test]
+        public void TestAddSeparator()
+        {
+            // Arrange
+            ContextMenu contextMenu = new ContextMenu();
+            NodeContextMenuBuilder.ContextMenu = contextMenu;
+
+            Assert.IsEmpty(contextMenu.Items);
+
+            // Act
+            NodeContextMenuBuilder.AddContextMenuSeparator();
+
+            // Assert
+            Assert.AreEqual(1, contextMenu.Items.Count);
+            Assert.IsInstanceOf(typeof(Separator), contextMenu.Items[0]);
+        }
+    }
+}