diff --git a/Changelog.md b/Changelog.md
index 5fcc859a7b..59ee5de2ae 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -3,6 +3,7 @@
 ## Unreleased
 - Maven: add support for maven scope filtering ([#1331](https://github.com/fossas/fossa-cli/pull/1331))
 - `fossa init`: adds new `fossa init` command which creates `.fossa.yml.example`, and `fossa-deps.yml.example` file. ([#1323](https://github.com/fossas/fossa-cli/pull/1323))
+- Maven: add support for maven submodule filtering
 
 ## v3.8.24
 
diff --git a/docs/references/strategies/languages/gradle/gradle.md b/docs/references/strategies/languages/gradle/gradle.md
index 35b6873624..ffea291bd4 100644
--- a/docs/references/strategies/languages/gradle/gradle.md
+++ b/docs/references/strategies/languages/gradle/gradle.md
@@ -338,7 +338,7 @@ targets:
 ```
 
 
-1) Running `fossa analyze --output -c .fossa.yml`, will only analyze `utilities` submodule.
+1) Running `fossa analyze --output -c .fossa.yml`, will only analyze `list` submodule.
 
 ## (Experimental) Only Selecting Set of Configurations For Analysis
 
diff --git a/docs/references/strategies/languages/maven/maven.md b/docs/references/strategies/languages/maven/maven.md
index d3d574995b..cfb90c34e0 100644
--- a/docs/references/strategies/languages/maven/maven.md
+++ b/docs/references/strategies/languages/maven/maven.md
@@ -51,6 +51,67 @@ maven:
     - test
 ```
 
+## Filtering by submodules
+
+If you have maven project which has one or more subprojects, you may
+only want to analyze a specific set of subprojects in some cases.
+
+
+In `fossa-cli`, this can be achieved by using [exclusion filtering](./../../../files/fossa-yml.md).
+
+1) Run `fossa list-targets`, to identify project directory and identifier of subprojects.
+```bash
+[ INFO] Found project: maven@./
+[ INFO] Found target: maven@./:com.fossa:app
+[ INFO] Found target: maven@./:com.fossa:list
+[ INFO] Found target: maven@./:com.fossa:utilities
+```
+
+Note that, targets are denoted in following format `type@path:target`. For example `maven@./:com.fossa:utilities`:
+
+Note: maven submodules targets are composed of `<groupId>:<artifactId>`, so the utilities submodule here is referenced by "com.fossa:utilities"
+```
+maven   @           ./      :      com.fossa:utilities
+------ ---          ---    ---        -----------
+Type   Path         Path   Target      Target
+       separator           separator
+```
+
+2) Now to analyze only `utilities`, use a `.fossa.yml` file in the project root.
+
+```yaml
+# filename: .fossa.yml
+#
+# analyze only maven@./:com.fossa:utilities
+version: 3
+targets:
+  only:
+    - type: maven
+      path: ./
+      target: 'com.fossa:utilities'
+```
+
+Likewise, if you want to exclude specific set of subprojects, you can do following:
+
+```yaml
+# filename: .fossa.yml
+#
+# do not analyze maven@./:com.fossa:app, and maven@./:com.fossa:utilities
+version: 3
+targets:
+  only:
+    - type: maven
+  exclude:
+    - type: maven
+      path: ./
+      target: 'com.fossa:app'
+    - type: gradle
+      path: ./
+      target: 'com.fossa:utilities'
+```
+
+1) Running `fossa analyze --output -c .fossa.yml`, will only analyze `utilities` submodule.
+
 <!--
 
 TODO: write docs, like Gradle's.
diff --git a/src/App/Fossa/Analyze.hs b/src/App/Fossa/Analyze.hs
index dfa7df2019..00eb8bd6c0 100644
--- a/src/App/Fossa/Analyze.hs
+++ b/src/App/Fossa/Analyze.hs
@@ -201,7 +201,6 @@ runDependencyAnalysis basedir filters pathPrefix project@DiscoveredProject{..} =
   case (applyFiltersToProject basedir filters project, hasNonProductionPath) of
     (Nothing, _) -> do
       logInfo $ "Skipping " <> pretty projectType <> " project at " <> viaShow projectPath <> ": no filters matched"
-      logDebug $ "WE ARE SKIPPING HERE -----"
       output $ SkippedDueToProvidedFilter dpi
     (Just _, True) -> do
       logInfo $ "Skipping " <> pretty projectType <> " project at " <> viaShow projectPath <> " (default non-production path filtering)"
@@ -209,10 +208,6 @@ runDependencyAnalysis basedir filters pathPrefix project@DiscoveredProject{..} =
     (Just targets, False) -> do
       logInfo $ "Analyzing " <> pretty projectType <> " project at " <> pretty (toFilePath projectPath)
       let ctxMessage = "Project Analysis: " <> showT projectType
-      let x = project
-      logDebug $ "Here are the targets -----" <> pretty (pShow (targets))
-      -- logDebug $ "Project Data -----" <> pretty (showT (projectData))
-
       graphResult <- Diag.runDiagnosticsIO . diagToDebug . stickyLogStack . withEmptyStack . Diag.context ctxMessage $ do
         debugMetadata "DiscoveredProject" project
         trackTimeSpent (showT projectType) $ analyzeProject targets projectData
@@ -280,7 +275,7 @@ analyze cfg = Diag.context "fossa-analyze" $ do
       grepOptions = Config.grepOptions cfg
       customFossaDepsFile = Config.customFossaDepsFile cfg
       shouldAnalyzePathDependencies = resolvePathDependencies $ Config.experimental cfg
-  logDebug $ "All Filters From Config: ----------" <> pretty (pShow (filters))
+
   -- additional source units are built outside the standard strategy flow, because they either
   -- require additional information (eg API credentials), or they return additional information (eg user deps).
   vsiResults <- Diag.errorBoundaryIO . diagToDebug $
diff --git a/src/App/Fossa/Config/Analyze.hs b/src/App/Fossa/Config/Analyze.hs
index 9a57b1adfa..cb55d20b7b 100644
--- a/src/App/Fossa/Config/Analyze.hs
+++ b/src/App/Fossa/Config/Analyze.hs
@@ -427,8 +427,7 @@ mergeStandardOpts maybeConfig envvars cliOpts@AnalyzeCliOpts{..} = do
       dynamicAnalysisOverrides = OverrideDynamicAnalysisBinary $ envCmdOverrides envvars
       grepOptions = collectGrepOptions maybeConfig cliOpts
       customFossaDepsFile = analyzeCustomFossaDepsFile
-  x <- collectFilters maybeConfig cliOpts
-  logDebug $ "The filters ---" <> pretty (pShow (x))
+
   firstPartyScansFlag <-
     case (fromFlag ForceFirstPartyScans analyzeForceFirstPartyScans, fromFlag ForceNoFirstPartyScans analyzeForceNoFirstPartyScans) of
       (True, True) -> fatalText "You provided both the --experimental-force-first-party-scans and --experimental-block-first-party-scans flags. Only one of these flags may be used"
diff --git a/src/Graphing.hs b/src/Graphing.hs
index 0e2f7d6fa3..c815356006 100644
--- a/src/Graphing.hs
+++ b/src/Graphing.hs
@@ -48,8 +48,6 @@ module Graphing (
   promoteToDirect,
   shrinkRoots,
   subGraphOf,
-  deleteNodeAndChildren,
-  reachableNodes,
 
   -- * Conversions
   fromAdjacencyMap,
@@ -396,27 +394,6 @@ subGraphOf n (Graphing gr) =
     keepPredicate Root = True
     keepPredicate (Node ty) = Set.member (Node ty) reachableNodes
 
--- Delete a node and its children from the Graphing based on a condition
-deleteNodeAndChildren :: forall ty. Ord ty => (ty -> Bool) -> ty -> Graphing ty -> Graphing ty
-deleteNodeAndChildren f node (Graphing gr) =
-  Graphing $ AM.removeVertex (Node node) (AM.induce keepPredicate gr)
-  where
-    nodes :: [Node ty]
-    nodes = Prelude.filter (== Node node) $ AM.vertexList gr
-
-    reachableNodes :: Set.Set (Node ty)
-    reachableNodes = Set.fromList $ AMA.dfs gr nodes
-
-    keepPredicate :: Node ty -> Bool
-    keepPredicate Root = True
-    keepPredicate (Node ty) = Set.notMember (Node ty) reachableNodes || f ty
-
-reachableNodes :: forall ty. Ord ty => Set.Set ty -> Graphing ty -> Set.Set ty
-reachableNodes nodeSet (Graphing gr) = Set.fromList $ AMA.dfs (toAdjacencyMap (Graphing gr)) nodes
-  where
-    nodes :: [ty]
-    nodes = Prelude.filter (`Set.member` nodeSet) $ AM.vertexList (toAdjacencyMap (Graphing gr))
-
 -- where
 --   node' = if condition node then node else mempty
 
diff --git a/src/Strategy/Maven.hs b/src/Strategy/Maven.hs
index 06a5f20df0..f34a636337 100644
--- a/src/Strategy/Maven.hs
+++ b/src/Strategy/Maven.hs
@@ -1,4 +1,6 @@
+{-# LANGUAGE RecordWildCards #-}
 {-# OPTIONS_GHC -Wno-incomplete-patterns #-}
+{-# OPTIONS_GHC -Wno-name-shadowing #-}
 
 module Strategy.Maven (
   discover,
@@ -14,8 +16,6 @@ import Control.Effect.Diagnostics (Diagnostics, context, warnOnErr, (<||>))
 import Control.Effect.Lift (Lift)
 import Control.Effect.Reader (Reader, ask)
 import Data.Aeson (ToJSON)
-import Data.Map.Strict (Map)
-import Data.Set (Set)
 import Data.Set qualified as Set
 import Data.Set.NonEmpty (nonEmpty, toSet)
 import Data.Text hiding (group)
@@ -24,34 +24,26 @@ import Diag.Common (MissingDeepDeps (MissingDeepDeps), MissingEdges (MissingEdge
 import Discovery.Filters (AllFilters, MavenScopeFilters)
 import Discovery.Simple (simpleDiscover)
 import Effect.Exec (CandidateCommandEffs)
-import Effect.Logger (Logger)
 import Effect.ReadFS (ReadFS)
 import GHC.Generics (Generic)
-import Graphing (Graphing, edgesList, gmap, shrinkRoots, toAdjacencyMap, vertexList)
+import Graphing (Graphing, gmap, shrinkRoots)
 import Path (Abs, Dir, Path, parent)
 import Strategy.Maven.Common (MavenDependency (..), filterMavenDependencyByScope, filterMavenSubmodules, mavenDependencyToDependency)
 import Strategy.Maven.DepTree qualified as DepTreeCmd
 import Strategy.Maven.PluginStrategy qualified as Plugin
 import Strategy.Maven.Pom qualified as Pom
-import Strategy.Maven.Pom.Closure (MavenProjectClosure)
+import Strategy.Maven.Pom.Closure (MavenProjectClosure (..))
 import Strategy.Maven.Pom.Closure qualified as PomClosure
 
-import Effect.Logger (Logger, Pretty (pretty), logDebug, runLogger)
-import Text.Pretty.Simple (pShow)
+import Algebra.Graph.AdjacencyIntMap ()
+import Data.Set (Set)
 import Types (BuildTarget (..), DependencyResults (..), DiscoveredProject (..), DiscoveredProjectType (MavenProjectType), FoundTargets (..), GraphBreadth (..))
 
-import Algebra.Graph.AdjacencyMap (edgeList)
-import Data.Map qualified as Map
-import Debug.Trace (traceM)
-import Effect.Logger (Logger, Pretty (pretty), logDebug, runLogger)
-import Strategy.Maven.Pom.PomFile (MavenCoordinate (MavenCoordinate))
-
 discover ::
   ( Has (Lift IO) sig m
   , Has Diagnostics sig m
   , Has ReadFS sig m
   , Has (Reader AllFilters) sig m
-  , Has Logger sig m
   ) =>
   Path Abs Dir ->
   m [DiscoveredProject MavenProject]
@@ -66,8 +58,7 @@ mkProject (MavenProject closure) = do
   DiscoveredProject
     { projectType = MavenProjectType
     , projectPath = parent $ PomClosure.closurePath closure
-    , -- , projectBuildTargets = maybe ProjectWithoutTargets FoundTargets $ nonEmpty $ Set.map BuildTarget testSet
-      projectBuildTargets = maybe ProjectWithoutTargets FoundTargets $ nonEmpty $ Set.map BuildTarget $ PomClosure.closureSubmodules closure
+    , projectBuildTargets = maybe ProjectWithoutTargets FoundTargets $ nonEmpty $ Set.map BuildTarget $ PomClosure.closureSubmodules closure
     , projectData = MavenProject closure
     }
 
@@ -78,7 +69,7 @@ instance ToJSON MavenProject
 
 instance AnalyzeProject MavenProject where
   analyzeProject = getDeps
-  analyzeProject' _ = getDeps'
+  analyzeProject' = getDeps'
 
 instance LicenseAnalyzeProject MavenProject where
   licenseAnalyzeProject = pure . Pom.getLicenses . unMavenProject
@@ -87,35 +78,18 @@ getDeps ::
   ( Has (Lift IO) sig m
   , Has ReadFS sig m
   , CandidateCommandEffs sig m
-  , Has Logger sig m
-  , Has Logger sig m
   , Has (Reader MavenScopeFilters) sig m
   ) =>
   FoundTargets ->
   MavenProject ->
   m DependencyResults
 getDeps foundTargets (MavenProject closure) = do
-  let targetSet :: Set.Set Text
-      targetSet = case foundTargets of
-        FoundTargets targets -> Set.map unBuildTarget (toSet targets)
-        _ -> Set.empty
-
-  logDebug $ "Targets in get Deps for Maven " <> pretty (pShow (targetSet))
-  logDebug $ "Closure submodule set " <> pretty (pShow (PomClosure.closureSubmodules closure))
-  -- (graph, graphBreadth) <- context "Maven" $ getDepsDynamicAnalysis closure <||> getStaticAnalysis closure
-  (graph, graphBreadth) <- context "Maven" $ getStaticAnalysis (PomClosure.closureSubmodules closure) closure
-
-  -- logDebug $ "This is the EdgeList((((((()))))))" <> pretty (pShow (edgesList graph))
-  submodulesToDeleteGraph <- filterMavenSubmodules targetSet (PomClosure.closureSubmodules closure) graph
-  logDebug $ "This is the Graph ((((((()))))))" <> pretty (pShow (graph))
-  -- logDebug $ "Shrink This is the Graph ((((((()))))))" <> pretty (pShow (shrinkRoots graph))
-  logDebug $ "This is the Graph after filtering submodules **********" <> pretty (pShow (submodulesToDeleteGraph))
-  -- logDebug $ "This is vertex lsit of nodes to delete ((((((()))))))" <> pretty (pShow (vertexList submodulesToDeleteGraph))
-  -- logDebug $ "This is the adjacency Map ((((((()))))))" <> pretty (pShow (Graphing.toAdjacencyMap graph))
+  let submoduleTargets = submoduleTargetSet foundTargets
+  (graph, graphBreadth) <- context "Maven" $ getDepsDynamicAnalysis submoduleTargets closure <||> getStaticAnalysis submoduleTargets closure
 
   pure $
     DependencyResults
-      { dependencyGraph = filteredGraph
+      { dependencyGraph = graph
       , dependencyGraphBreadth = graphBreadth
       , dependencyManifestFiles = [PomClosure.closurePath closure]
       }
@@ -124,17 +98,17 @@ getDeps' ::
   ( Has (Lift IO) sig m
   , Has Diagnostics sig m
   , Has (Reader MavenScopeFilters) sig m
-  , Has Logger sig m
   ) =>
+  FoundTargets ->
   MavenProject ->
   m DependencyResults
-getDeps' (MavenProject closure) = do
-  (graph, graphBreadth) <- context "Maven" $ getStaticAnalysis closure
-  filteredGraph <- withScopeFiltering graph
+getDeps' foundTargets (MavenProject closure) = do
+  let submoduleTargets = submoduleTargetSet foundTargets
+  (graph, graphBreadth) <- context "Maven" $ getStaticAnalysis submoduleTargets closure
 
   pure $
     DependencyResults
-      { dependencyGraph = filteredGraph
+      { dependencyGraph = graph
       , dependencyGraphBreadth = graphBreadth
       , dependencyManifestFiles = [PomClosure.closurePath closure]
       }
@@ -143,23 +117,33 @@ getDepsDynamicAnalysis ::
   ( Has (Lift IO) sig m
   , Has ReadFS sig m
   , CandidateCommandEffs sig m
-  , Has Logger sig m
+  , Has (Reader MavenScopeFilters) sig m
   ) =>
+  Set Text ->
   MavenProjectClosure ->
-  m (Graphing MavenDependency, GraphBreadth)
-getDepsDynamicAnalysis closure = do
-  context "Dynamic Analysis"
-    $ warnOnErr MissingEdges
-      . warnOnErr MissingDeepDeps
-    $ getDepsTreeCmd closure
-
--- (getDepsPlugin closure <||> getDepsTreeCmd closure <||> getDepsPluginLegacy closure)
+  m (Graphing Dependency, GraphBreadth)
+getDepsDynamicAnalysis submoduleTargets closure = do
+  let allSubmodules = completeSubmoduleSet closure
+  (graph, graphBreadth) <-
+    context "Dynamic Analysis"
+      $ warnOnErr MissingEdges
+        . warnOnErr MissingDeepDeps
+      $ (getDepsPlugin closure <||> getDepsTreeCmd closure <||> getDepsPluginLegacy closure)
+  filteredGraph <- applyMavenFilters submoduleTargets allSubmodules graph
+  pure (withoutProjectAsDep filteredGraph, graphBreadth)
+  where
+    -- shrinkRoots is applied on all dynamic strategies. Previously, this was done downstream but now we are moving it upstream.
+    -- This allows us to have reference to the submodules so that we can filter
+    -- The root deps in the maven depgraph text graph output are either the
+    -- toplevel package or submodules in a multi-module project. We don't want to
+    -- consider those because they're the users' packages, so promote them to
+    -- direct when building the graph using `shrinkRoots`.
+    withoutProjectAsDep = shrinkRoots
 
 getDepsPlugin ::
   ( CandidateCommandEffs sig m
   , Has (Lift IO) sig m
   , Has ReadFS sig m
-  , Has Logger sig m
   ) =>
   MavenProjectClosure ->
   m (Graphing MavenDependency, GraphBreadth)
@@ -169,7 +153,6 @@ getDepsPluginLegacy ::
   ( CandidateCommandEffs sig m
   , Has (Lift IO) sig m
   , Has ReadFS sig m
-  , Has Logger sig m
   ) =>
   MavenProjectClosure ->
   m (Graphing MavenDependency, GraphBreadth)
@@ -179,7 +162,6 @@ getDepsTreeCmd ::
   ( Has (Lift IO) sig m
   , Has ReadFS sig m
   , CandidateCommandEffs sig m
-  , Has Logger sig m
   ) =>
   MavenProjectClosure ->
   m (Graphing MavenDependency, GraphBreadth)
@@ -191,14 +173,29 @@ getDepsTreeCmd closure = do
 getStaticAnalysis ::
   ( Has (Lift IO) sig m
   , Has Diagnostics sig m
+  , Has (Reader MavenScopeFilters) sig m
   ) =>
   Set Text ->
   MavenProjectClosure ->
-  m (Graphing MavenDependency, GraphBreadth)
-getStaticAnalysis closure = do
-  context "Static analysis" $ pure (Pom.analyze' closure, Partial)
-
-withScopeFiltering :: Has (Reader MavenScopeFilters) sig m => Graphing MavenDependency -> m (Graphing Dependency)
-withScopeFiltering graph = do
+  m (Graphing Dependency, GraphBreadth)
+getStaticAnalysis submoduleTargets closure = do
+  let allSubmodules = completeSubmoduleSet closure
+  (graph, graphBreadth) <- context "Static analysis" $ pure (Pom.analyze' closure, Partial)
+  filteredGraph <- applyMavenFilters submoduleTargets allSubmodules graph
+  pure (filteredGraph, graphBreadth)
+
+applyMavenFilters :: Has (Reader MavenScopeFilters) sig m => Set Text -> Set Text -> Graphing MavenDependency -> m (Graphing Dependency)
+applyMavenFilters submoduleTargetSet completeSubmoduleSet graph = do
   mavenScopeFilters <- ask @(MavenScopeFilters)
-  pure $ gmap mavenDependencyToDependency $ filterMavenDependencyByScope mavenScopeFilters graph
+  let filteredSubmoduleGraph = filterMavenSubmodules submoduleTargetSet completeSubmoduleSet graph
+      filteredSubmoduleScopeGraph = filterMavenDependencyByScope mavenScopeFilters filteredSubmoduleGraph
+
+  pure $ gmap mavenDependencyToDependency filteredSubmoduleScopeGraph
+
+submoduleTargetSet :: FoundTargets -> Set Text
+submoduleTargetSet foundTargets = case foundTargets of
+  FoundTargets targets -> Set.map unBuildTarget (toSet targets)
+  _ -> Set.empty
+
+completeSubmoduleSet :: MavenProjectClosure -> Set Text
+completeSubmoduleSet MavenProjectClosure{..} = closureSubmodules
\ No newline at end of file
diff --git a/src/Strategy/Maven/Common.hs b/src/Strategy/Maven/Common.hs
index 22faa93e44..42bd699182 100644
--- a/src/Strategy/Maven/Common.hs
+++ b/src/Strategy/Maven/Common.hs
@@ -4,20 +4,17 @@ module Strategy.Maven.Common (
   MavenDependency (..),
   mavenDependencyToDependency,
   filterMavenSubmodules,
-  --   filterMavenDependencyByScope,
+  filterMavenDependencyByScope,
 ) where
 
-import Data.Set (Set, unions)
+import Data.Set (Set)
 import Data.Set qualified as Set
 import Data.Text (Text)
 import DepTypes (Dependency (..))
 
--- import Discovery.Filters (FilterSet (scopes), MavenScopeFilters (..))
+import Discovery.Filters (FilterSet (scopes), MavenScopeFilters (..))
 
-import Algebra.Graph.AdjacencyMap qualified as AM
-import Data.Foldable (Foldable (foldl'), for_)
-import Debug.Trace (trace, traceM)
-import Graphing (Graphing, Node (Node), deleteNodeAndChildren, edgesList, filter, reachableNodes, shrink, vertexList)
+import Graphing (Graphing, edgesList, filter, shrink, vertexList)
 
 data MavenDependency = MavenDependency
   { dependency :: Dependency
@@ -28,21 +25,21 @@ data MavenDependency = MavenDependency
 mavenDependencyToDependency :: MavenDependency -> Dependency
 mavenDependencyToDependency MavenDependency{..} = dependency
 
-filterMavenSubmodules :: Monad m => Set Text -> Set Text -> Graphing MavenDependency -> m (Graphing MavenDependency)
-filterMavenSubmodules targetSet submoduleSet graph = do
-  let filteredSubmoduleNames = submoduleSet `Set.difference` targetSet
-      filteredSubmoduleNodes = Set.fromList $ Prelude.filter (\dep -> depNameFromMavenDependency dep `Set.member` filteredSubmoduleNames) $ vertexList graph
+filterMavenSubmodules :: Set Text -> Set Text -> Graphing MavenDependency -> (Graphing MavenDependency)
+filterMavenSubmodules includedSubmoduleSet completeSubmoduleSet graph = do
+  let excludedSubmoduleSet = completeSubmoduleSet `Set.difference` includedSubmoduleSet
+      excludedSubmodules = Set.fromList $ Prelude.filter (\dep -> depNameFromMavenDependency dep `Set.member` excludedSubmoduleSet) $ vertexList graph
       -- Find all the dependencies of the submodules that will be included in the scan
-      targetSubmoduleDependencies = resultSet targetSet
-      -- Find the dependencies of the filtered submodules
-      -- After, we want to take the intersection of filteredSubmoduleDependencies && targetSubmoduleDependencies to get all the shared dependencies
-      -- Next, take the difference of filteredSubmoduleDependencies && sharedDependencies to not filter out any shared dependencies
-      -- We also want to union all the filteredSubmoduleNodes with our previous result to get a fully complete set of nodes to exclude.
-      filteredSubmoduleDependencies = resultSet filteredSubmoduleNames
-      sharedDependencies = filteredSubmoduleDependencies `Set.intersection` targetSubmoduleDependencies
-      mavenDependenciesToRemove = filteredSubmoduleNodes `Set.union` (filteredSubmoduleDependencies `Set.difference` sharedDependencies)
-
-  pure $ Graphing.filter (shouldIncludeMavenDependency mavenDependenciesToRemove) graph
+      includedSubmoduleDependencies = combinedMavenDependencySet includedSubmoduleSet
+      -- Find the dependencies of the excluded submodules
+      -- After, we want to take the intersection of excludedSubmoduleDependencies && includedSubmoduleDependencies to get all the shared dependencies
+      -- Next, take the difference of excludedSubmoduleDependencies && sharedDependencies so we don't filter out any shared dependencies
+      -- We also want to union all the excludedSubmodules with our previous result to add the submodules back in order to get a complete set of nodes to exclude.
+      excludedSubmoduleDependencies = combinedMavenDependencySet excludedSubmoduleSet
+      sharedDependencies = excludedSubmoduleDependencies `Set.intersection` includedSubmoduleDependencies
+      mavenDependenciesToRemove = excludedSubmodules `Set.union` (excludedSubmoduleDependencies `Set.difference` sharedDependencies)
+
+  Graphing.filter (shouldIncludeMavenDependency mavenDependenciesToRemove) graph
   where
     shouldIncludeMavenDependency :: Set MavenDependency -> MavenDependency -> Bool
     shouldIncludeMavenDependency mavenDepExclusionSet mavenDep = mavenDep `Set.notMember` mavenDepExclusionSet
@@ -53,40 +50,17 @@ filterMavenSubmodules targetSet submoduleSet graph = do
     depNameFromMavenDependency :: MavenDependency -> Text
     depNameFromMavenDependency MavenDependency{..} = dependencyName dependency
 
-    -- findTransitiveDependencies is used to find the all depedencies of a submodule excluding its submodule dependencies
-    -- it also does not include the input submodule as part of its set, just strictly its dependencies
+    -- Used to find the all depedencies of a submodule (excluding dependencies that are submodules)
+    -- It also does not include the input submodule as part of its set, just strictly its dependencies
     findTransitiveDependencies :: Text -> [(MavenDependency, MavenDependency)] -> Set MavenDependency
     findTransitiveDependencies vertexName edges = do
-      let directDependencies = [neighborDep | (sourceDep, neighborDep) <- edges, depNameFromMavenDependency sourceDep == vertexName && (depNameFromMavenDependency neighborDep) `Set.notMember` submoduleSet]
+      let directDependencies = [neighborDep | (sourceDep, neighborDep) <- edges, depNameFromMavenDependency sourceDep == vertexName && (depNameFromMavenDependency neighborDep) `Set.notMember` completeSubmoduleSet]
           transitiveDependencies = Set.unions $ map (\dep -> findTransitiveDependencies (depNameFromMavenDependency dep) edges) directDependencies
        in Set.fromList directDependencies `Set.union` transitiveDependencies
 
-    -- given a set of submodules, resultSet combines all the transitive dependencies of every submodule in from the input set
-    resultSet :: Set Text -> Set MavenDependency
-    resultSet submodules = Set.foldr (\vertexName acc -> (findTransitiveDependencies vertexName edgeList) `Set.union` acc) Set.empty submodules
-{-# LANGUAGE RecordWildCards #-}
-
-module Strategy.Maven.Common (
-  MavenDependency (..),
-  mavenDependencyToDependency,
-  filterMavenDependencyByScope,
-) where
-
-import Data.Set (Set)
-import Data.Set qualified as Set
-import Data.Text (Text)
-import DepTypes (Dependency)
-import Discovery.Filters (FilterSet (scopes), MavenScopeFilters (..))
-import Graphing (Graphing, shrink)
-
-data MavenDependency = MavenDependency
-  { dependency :: Dependency
-  , dependencyScopes :: Set Text
-  }
-  deriving (Eq, Ord, Show)
-
-mavenDependencyToDependency :: MavenDependency -> Dependency
-mavenDependencyToDependency MavenDependency{..} = dependency
+    -- Given a set of submodule names, combine all the transitive dependencies of every submodule from the input set
+    combinedMavenDependencySet :: Set Text -> Set MavenDependency
+    combinedMavenDependencySet = Set.foldr (\vertexName acc -> (findTransitiveDependencies vertexName edgeList) `Set.union` acc) Set.empty
 
 filterMavenDependencyByScope :: MavenScopeFilters -> Graphing MavenDependency -> Graphing MavenDependency
 filterMavenDependencyByScope scopeFilters = Graphing.shrink isMavenDependencyIncluded
diff --git a/src/Strategy/Maven/DepTree.hs b/src/Strategy/Maven/DepTree.hs
index 744706bd98..ab68ebd9b5 100644
--- a/src/Strategy/Maven/DepTree.hs
+++ b/src/Strategy/Maven/DepTree.hs
@@ -18,15 +18,13 @@ import Control.Effect.Exception (SomeException, finally)
 import Control.Effect.Lift (Lift, sendIO)
 import Control.Exception.Extra (safeTry)
 import Data.Char (isSpace)
-import Data.Foldable (Foldable (foldl'), for_)
+import Data.Foldable (for_)
 import Data.Maybe (maybeToList)
-import Data.Set (Set)
 import Data.Set qualified as Set
 import Data.String.Conversion (toString, toText)
 import Data.Text (Text)
 import Data.Text qualified as Text
 import Data.Void (Void)
-import Debug.Trace (traceM, traceShowM)
 import DepTypes (
   DepEnvironment (..),
   DepType (MavenType),
@@ -35,7 +33,6 @@ import DepTypes (
  )
 import Effect.Exec (AllowErr (..), CandidateCommandEffs, Command (..), exec, mkAnalysisCommand)
 import Effect.Grapher (direct, edge, evalGrapher)
-import Effect.Logger (Logger, Pretty (pretty), logDebug, runLogger)
 import Effect.ReadFS (ReadFS, doesFileExist, readContentsParser)
 import Graphing (Graphing, gmap, shrinkRoots)
 import Path (Abs, Dir, File, Path, Rel, fromAbsFile, parseRelFile, (</>))
@@ -52,7 +49,6 @@ import Text.Megaparsec (
  )
 import Text.Megaparsec.Char (space1)
 import Text.Megaparsec.Char.Lexer qualified as Lexer
-import Text.Pretty.Simple (pShow)
 import Types (GraphBreadth (Complete))
 
 -- Construct the Command for running `mvn dependency:tree` correctly.
@@ -151,9 +147,7 @@ analyze dir = do
       Nothing -> fatal $ toText $ "invalid file name: " <> f
 
 buildGraph :: [DotGraph] -> Graphing MavenDependency
-buildGraph = withoutProjectAsDep . gmap toDependency . foldMap toGraph
-  where
-    withoutProjectAsDep = shrinkRoots
+buildGraph = gmap toDependency . foldMap toGraph
 
 toDependency :: PackageId -> MavenDependency
 toDependency PackageId{groupName, artifactName, artifactVersion, buildTag} = do
diff --git a/src/Strategy/Maven/PluginStrategy.hs b/src/Strategy/Maven/PluginStrategy.hs
index 798d74667c..e5d51de0f1 100644
--- a/src/Strategy/Maven/PluginStrategy.hs
+++ b/src/Strategy/Maven/PluginStrategy.hs
@@ -16,26 +16,22 @@ import Control.Effect.Diagnostics (
  )
 import Control.Effect.Lift (Lift)
 import Control.Monad (when)
-import Data.Foldable (Foldable (foldl'), traverse_)
-import Data.List (nub)
-import Data.Map.Strict (Map, delete, insert, member, (!))
+import Data.Foldable (traverse_)
+import Data.Map.Strict (Map)
 import Data.Map.Strict qualified as Map
 import Data.Set qualified as Set
 import Data.Text (Text)
-import Debug.Trace
-import Debug.Trace (traceM, traceShowM)
 import DepTypes (
   DepEnvironment (..),
   DepType (MavenType),
   Dependency (..),
   VerConstraint (CEq),
  )
-import Effect.Exec (CandidateCommandEffs, exec)
+import Effect.Exec (CandidateCommandEffs)
 import Effect.Grapher (Grapher, edge, evalGrapher)
 import Effect.Grapher qualified as Grapher
-import Effect.Logger (Logger, Pretty (pretty), logDebug, runLogger)
 import Effect.ReadFS (ReadFS)
-import Graphing (Graphing, shrinkRoots)
+import Graphing (Graphing)
 import Path (Abs, Dir, Path)
 import Strategy.Maven.Common (MavenDependency (..))
 import Strategy.Maven.Plugin (
@@ -55,15 +51,12 @@ import Strategy.Maven.Plugin (
   reactorArtifacts,
   withUnpackedPlugin,
  )
-import Text.Pretty.Simple (pPrint, pShow, pShowNoColor)
-import Text.Show.Pretty qualified as Pr
 import Types (GraphBreadth (..))
 
 analyze' ::
   ( CandidateCommandEffs sig m
   , Has (Lift IO) sig m
   , Has ReadFS sig m
-  , Has Logger sig m
   ) =>
   Path Abs Dir ->
   m (Graphing MavenDependency, GraphBreadth)
@@ -73,7 +66,6 @@ analyzeLegacy' ::
   ( CandidateCommandEffs sig m
   , Has (Lift IO) sig m
   , Has ReadFS sig m
-  , Has Logger sig m
   ) =>
   Path Abs Dir ->
   m (Graphing MavenDependency, GraphBreadth)
@@ -148,58 +140,16 @@ instance ToDiagnostic MayIncludeSubmodule where
 -- tree and promote submodule1's dependency to be a root (direct) dependency.
 buildGraph :: ReactorOutput -> PluginOutput -> Graphing MavenDependency
 buildGraph reactorOutput PluginOutput{..} =
-  -- The root deps in the maven depgraph text graph output are either the
-  -- toplevel package or submodules in a multi-module project. We don't want to
-  -- consider those because they're the users' packages, so promote them to
-  -- direct when building the graph using `shrinkRoots`.
-
   run . evalGrapher $ do
-    -- shrinkRoots . run . evalGrapher $ do
     let byNumeric :: Map Int Artifact
         byNumeric = indexBy artifactNumericId outArtifacts
-    traceM ("This is by numeric: " ++ show (byNumeric))
-
-    traceM ("The original output Artifacts: =========")
-    traceShowM (outArtifacts)
-
-    traceM ("The original output Artifact edges: =========")
-    traceShowM (outEdges)
-
-    traceM ("The reactor out Artifacts: =========")
-    traceShowM (reactorArtifacts $ reactorOutput)
-
-    let filteredNumsByNumeric = Map.filterWithKey (\k _ -> k `Set.notMember` filterSubmoduleSet) byNumeric
-    traceM ("The filtered by numeric")
-    traceShowM filteredNumsByNumeric
-
-    -- depsByNumeric <- traverse toDependency filteredNumsByNumeric
     depsByNumeric <- traverse toDependency byNumeric
-    traceM ("This is deps by numeric ***********")
-    traceShowM depsByNumeric
-
-    let (updatedV, updatedE) = removeVertex 7 depsByNumeric outEdges
-    -- traceM ("This is updated Deps and ############" ++ show (updatedV))
-    -- -- traceM x
-
-    -- traceM ("This is updated edges ############" ++ show (updatedE))
-
-    let transativeDepExec = findTransitiveDependencies 7 outEdges
-    let transativeDepLib = findTransitiveDependencies 6 outEdges
-
-    traceM ("This si the transative edges of Exec ######### " ++ show (transativeDepExec))
-    traceM ("This si the transative edges of Lib ######### " ++ show (transativeDepLib))
 
     traverse_ (visitEdge depsByNumeric) outEdges
   where
-    filterArtifact :: [Artifact] -> [Artifact]
-    filterArtifact = filter (\x -> artifactArtifactId x `Set.notMember` Set.fromList ["exec"])
-
     knownSubmodules :: Set.Set Text
     knownSubmodules = Set.fromList . map reactorArtifactName . reactorArtifacts $ reactorOutput
 
-    filterSubmoduleSet :: Set.Set Int
-    filterSubmoduleSet = Set.fromList [7]
-
     toBuildTag :: Text -> DepEnvironment
     toBuildTag = \case
       "compile" -> EnvProduction
@@ -230,36 +180,11 @@ buildGraph reactorOutput PluginOutput{..} =
 
     visitEdge :: Has (Grapher MavenDependency) sig m => Map Int MavenDependency -> Edge -> m ()
     visitEdge refsByNumeric Edge{..} = do
-      traceM ("WITH WHEN STATEMENT +++++++++ ")
       let refs = do
             parentRef <- Map.lookup edgeFrom refsByNumeric
             childRef <- Map.lookup edgeTo refsByNumeric
             Just (parentRef, childRef)
       traverse_ (uncurry edge) refs
 
-    -- when
-    --   (edgeFrom `Set.notMember` filterSubmoduleSet && edgeTo `Set.notMember` filterSubmoduleSet)
-    --   $ traverse_ (uncurry edge) refs
-
     indexBy :: Ord k => (v -> k) -> [v] -> Map k v
     indexBy f = Map.fromList . map (\v -> (f v, v))
-
-    removeVertex :: Int -> Map Int Dependency -> [Edge] -> (Map Int Dependency, [Edge])
-    removeVertex targetVertex vertices edges =
-      let transitiveDependencies = findTransitiveDependencies targetVertex edges
-          allDependencies = targetVertex : transitiveDependencies
-          updatedVertices = foldl' (\acc v -> Map.delete v acc) vertices allDependencies
-          updatedEdges = filter (\(Edge from to) -> from `notElem` allDependencies && to `notElem` allDependencies) edges
-          sharedDependencies = nub $ concatMap (\dep -> findDirectDependencies dep edges) allDependencies
-          updatedEdgesWithShared = updatedEdges ++ filter (\(Edge from to) -> from `elem` sharedDependencies && to `elem` sharedDependencies) edges
-       in (updatedVertices, updatedEdgesWithShared)
-
-    findTransitiveDependencies :: Int -> [Edge] -> [Int]
-    findTransitiveDependencies vertexId edges =
-      let directDependencies = [to | Edge from to <- edges, from == vertexId && to /= 6]
-          transitiveDependencies = concatMap (\dep -> if dep /= 6 then findTransitiveDependencies dep edges else []) directDependencies
-       in directDependencies ++ transitiveDependencies
-
-    findDirectDependencies :: Int -> [Edge] -> [Int]
-    findDirectDependencies vertexId edges =
-      [to | Edge from to <- edges, from == vertexId]
diff --git a/src/Strategy/Maven/Pom.hs b/src/Strategy/Maven/Pom.hs
index eb3078d9b9..4aa8c73444 100644
--- a/src/Strategy/Maven/Pom.hs
+++ b/src/Strategy/Maven/Pom.hs
@@ -19,10 +19,8 @@ import Data.Set (Set)
 import Data.Set qualified as Set
 import Data.Text (Text)
 import Data.Text.Extra (breakOnAndRemove)
-import Debug.Trace (traceM, traceShowM)
 import DepTypes
 import Effect.Grapher
-import Effect.Logger (Logger, logDebug)
 import Graphing (Graphing)
 import Path
 import Path.IO qualified as Path
@@ -37,10 +35,8 @@ data MavenStrategyOpts = MavenStrategyOpts
   }
   deriving (Eq, Ord, Show)
 
-analyze' :: Set Text -> MavenProjectClosure -> Graphing MavenDependency
-analyze' = do
-  traceM ("Analyze of Pom ()()(())(()()())()()")
-  buildProjectGraph
+analyze' :: MavenProjectClosure -> Graphing MavenDependency
+analyze' = buildProjectGraph
 
 getLicenses :: MavenProjectClosure -> [LicenseResult]
 getLicenses closure = do
@@ -111,20 +107,12 @@ buildProjectGraph closure = run . withLabeling toDependency $ do
   direct (coordToPackage (closureRootCoord closure))
   go (closureRootCoord closure) (closureRootPom closure)
   where
-    getTargetName :: MavenCoordinate -> Text
-    getTargetName MavenCoordinate{..} = mconcat [coordGroup, ":", coordArtifact]
-
     go :: Has MavenGrapher sig m => MavenCoordinate -> Pom -> m ()
     go coord incompletePom = do
       _ <- Map.traverseWithKey addDep deps
       for_ childPoms $ \(childCoord, childPom) -> do
-        if getTargetName childCoord `Set.member` submoduleFilterSet
-          then do
-            edge (coordToPackage coord) (coordToPackage childCoord)
-            go childCoord childPom
-          else do
-            traceM "Skippping in gooooooooooooo"
-            pure ()
+        edge (coordToPackage coord) (coordToPackage childCoord)
+        go childCoord childPom
       where
         completePom :: Pom
         completePom = overlayParents incompletePom
diff --git a/src/Strategy/Maven/Pom/Closure.hs b/src/Strategy/Maven/Pom/Closure.hs
index 184c7b6135..b9d1415bbe 100644
--- a/src/Strategy/Maven/Pom/Closure.hs
+++ b/src/Strategy/Maven/Pom/Closure.hs
@@ -26,18 +26,13 @@ import Path
 import Path.IO qualified as PIO
 import Strategy.Maven.Pom.PomFile
 import Strategy.Maven.Pom.Resolver
-import Text.Pretty.Simple (pShow)
 
 import Data.Text (Text)
-import Effect.Logger (Logger, Pretty (pretty), logDebug, runLogger)
-import Text.Pretty.Simple (pShow)
 
-findProjects :: (Has ReadFS sig m, Has Diagnostics sig m, Has Logger sig m, Has Logger sig m) => Path Abs Dir -> m [MavenProjectClosure]
+findProjects :: (Has ReadFS sig m, Has Diagnostics sig m) => Path Abs Dir -> m [MavenProjectClosure]
 findProjects basedir = do
   pomFiles <- context "Finding pom files" $ findPomFiles basedir
   globalClosure <- context "Building global closure" $ buildGlobalClosure pomFiles
-  -- logDebug $ "List of Maven closures *******" <> pretty (pShow (buildProjectClosures basedir globalClosure))
-  -- logDebug $ "Maven Project Closure" <> pretty (pShow (globalClosure))
   context "Building project closures" $ pure (buildProjectClosures basedir globalClosure)
 
 findPomFiles :: (Has ReadFS sig m, Has Diagnostics sig m) => Path Abs Dir -> m [Path Abs File]
@@ -71,7 +66,7 @@ buildProjectClosures basedir global = closures
     submodulesFromCoordinate = Set.fromList . Prelude.map extractSubmoduleFromCoordinate . Map.keys
 
     extractSubmoduleFromCoordinate :: MavenCoordinate -> Text
-    extractSubmoduleFromCoordinate (MavenCoordinate group artifact _) = mconcat [group, ":", artifact]
+    extractSubmoduleFromCoordinate (MavenCoordinate group artifact _) = group <> ":" <> artifact
 
 -- Find reachable nodes both below (children, grandchildren, ...) and above (parents, grandparents) the node
 bidirectionalReachable :: Ord a => a -> AM.AdjacencyMap a -> Set.Set a
diff --git a/test/GraphingSpec.hs b/test/GraphingSpec.hs
index 57f3733070..0d9e0650f0 100644
--- a/test/GraphingSpec.hs
+++ b/test/GraphingSpec.hs
@@ -29,10 +29,7 @@ import Graphing (
   unfold,
   unfoldDeep,
   vertexList,
-  deleteNodeAndChildren,
-  filter,
  )
-import Debug.Trace (traceM)
 import Test.Hspec (
   Spec,
   context,
@@ -180,9 +177,6 @@ shrinkingSpec = context "Shrinking" $ do
           graph'' :: Graphing Int
           graph'' = Graphing.shrink (/= 1) (Graphing.direct 1 <> Graphing.edges [(1, 2), (2, 3), (3, 4)])
 
-      traceM("This is the graph" ++ show(graph))
-      traceM("This is the first filtered graph************" ++ show(graph'))
-      traceM("This is the second filtered graph----------" ++ show(graph''))
       expectDirect [] graph'
       expectDeps [1, 4, 5] graph'
       expectEdges [(1, 4), (4, 5)] graph'
@@ -208,28 +202,6 @@ shrinkingSpec = context "Shrinking" $ do
       expectDeps [1, 2, 4, 6, 7] graph'
       expectEdges [(1, 2), (2, 4), (2, 6), (2, 7)] graph'
 
-    it "should delete node and children" $ do
-      -- 1 -> 2 -> 5 -> 6
-      --      \    \
-      --       \    7
-      -- 3 ----> 4
-
-      let graph :: Graphing Int
-          graph = Graphing.edges [(1, 2), (3, 4), (2, 4), (2, 5), (5, 7), (5, 6)] <> Graphing.directs [1, 3]
-
-          graph' :: Graphing Int -> Graphing Int
-          graph' g = Graphing.deleteNodeAndChildren (\x -> x == 4 ) 3 g
-
-          x = graph 
-          x' = graph' x
-
-      traceM("This is the graph---------------" ++ show(x))
-      traceM("This is the graph after delete ************" ++ show(x'))
-      traceM("This is the graph after invoking the delete---------------" ++ show(x))
-      expectDirect [1] x'
-      expectDeps [1, 2, 5, 6, 7] x'
-      expectEdges [(1, 2), (2, 5), (5, 7), (5, 6)] x'
-
     it "should not promote any deps to direct" $ do
       --   1 -> 2 -> 5 -> 6
       --        \       \
diff --git a/test/Maven/CommonSpec.hs b/test/Maven/CommonSpec.hs
index 84849c6b52..4f9668b687 100644
--- a/test/Maven/CommonSpec.hs
+++ b/test/Maven/CommonSpec.hs
@@ -10,7 +10,7 @@ import Data.Set qualified as Set
 import Discovery.Filters (MavenScopeFilters (MavenScopeExcludeFilters, MavenScopeIncludeFilters), setExclude, setInclude)
 import GraphUtil
 import Graphing qualified
-import Strategy.Maven.Common (MavenDependency (..), filterMavenDependencyByScope)
+import Strategy.Maven.Common (MavenDependency (..), filterMavenDependencyByScope, filterMavenSubmodules)
 import Test.Hspec (Spec, describe, it)
 
 createDepFromScopes :: [Text] -> MavenDependency
@@ -26,8 +26,21 @@ createDepFromScopes scopes = do
           }
   MavenDependency dep (Set.fromList scopes)
 
-spec :: Spec
-spec = do
+createDepFromName :: Text -> MavenDependency
+createDepFromName depName = do 
+  let dep =
+        Dependency
+          { dependencyType = MavenType
+          , dependencyName = depName
+          , dependencyVersion = Just (CEq "1.0.0")
+          , dependencyLocations = []
+          , dependencyEnvironments = Set.fromList []
+          , dependencyTags = Map.fromList []
+          }
+  MavenDependency dep (Set.fromList [])
+
+scopeFilters :: Spec
+scopeFilters = do
   describe "Filter maven deps by scope" $ do
     it "should not filter from empty include set" $ do
       let compileDep = createDepFromScopes ["compile"]
@@ -175,3 +188,64 @@ spec = do
     expectDirect [compileDep] graph'
     expectDeps [compileDep, runtimeDep] graph'
     expectEdges [(compileDep, runtimeDep)] graph'
+
+
+submoduleFilters :: Spec
+submoduleFilters = do
+  describe "Filter maven deps by submodule" $ do
+    it "should filter submodule but not its shared dependencies" $ do
+      -- com.fossa:submodule2     ->   com.fossa:filteredDep
+      --                         \
+      -- com.fossa:submodule1 ->   com.fossa:sharedDep -> com.fossa:sharedDepTransitive
+      --
+      -- After filtering with includedSubmodules = Set("com.fossa:submodule1")
+      --
+      -- com.fossa:submodule1 ->  com.fossa:sharedDep -> com.fossa:sharedDepTransitive
+      let submoduleDep1 = createDepFromName "com.fossa:submodule1"
+      let submoduleDep2 = createDepFromName "com.fossa:submodule2"
+      let sharedDep = createDepFromName "com.fossa:sharedDep"
+      let sharedDepTransitive = createDepFromName "com.fossa:sharedDepTransitive"
+      let filteredDep = createDepFromName "com.fossa:filteredDep"
+          
+      let includedSubmodules = Set.fromList ["com.fossa:submodule1"]
+      let allSubmodules = Set.fromList ["com.fossa:submodule1", "com.fossa:submodule2"]
+
+      let graph = Graphing.directs [submoduleDep1, submoduleDep2] <> Graphing.edges [(submoduleDep1, sharedDep), (submoduleDep2, sharedDep), (submoduleDep2, filteredDep), (sharedDep, sharedDepTransitive)]
+      let graph' = filterMavenSubmodules includedSubmodules allSubmodules graph 
+
+      expectDirect [submoduleDep1] graph'
+      expectDeps [submoduleDep1, sharedDep, sharedDepTransitive] graph'
+      expectEdges [(submoduleDep1, sharedDep), (sharedDep, sharedDepTransitive)] graph'
+
+    it "should filter submodule when it is a dependency of another submodule and keep the shared dependencies" $ do
+      -- com.fossa:submodule1                    ->      com.fossa:sharedDep -> com.fossa:sharedDepTransitive
+      --                       \                       /
+      --                         com.fossa:submodule2 ->  com.fossa:filteredDep -> com.fossa:filteredDepTransitive
+      --
+      -- After filtering with includedSubmodules = Set("com.fossa:submodule1")
+      --
+      -- com.fossa:submodule1 ->  com.fossa:sharedDep -> com.fossa:sharedDepTransitive
+      let submoduleDep1 = createDepFromName "com.fossa:submodule1"
+      let submoduleDep2 = createDepFromName "com.fossa:submodule2"
+      let sharedDep = createDepFromName "com.fossa:sharedDep"
+      let sharedDepTransitive = createDepFromName "com.fossa:sharedDepTransitive"
+      let filteredDep = createDepFromName "com.fossa:filteredDep"
+      let filteredDepTransitive = createDepFromName "com.fossa:filteredDepTransitive"
+
+
+          
+      let includedSubmodules = Set.fromList ["com.fossa:submodule1"]
+      let allSubmodules = Set.fromList ["com.fossa:submodule1", "com.fossa:submodule2"]
+
+      let graph = Graphing.directs [submoduleDep1, submoduleDep2] <> Graphing.edges [(submoduleDep1, sharedDep), (submoduleDep1, submoduleDep2), (submoduleDep2, sharedDep), (submoduleDep2, filteredDep), (sharedDep, sharedDepTransitive), (filteredDep, filteredDepTransitive)]
+      let graph' = filterMavenSubmodules includedSubmodules allSubmodules graph 
+
+      expectDirect [submoduleDep1] graph'
+      expectDeps [submoduleDep1, sharedDep, sharedDepTransitive] graph'
+      expectEdges [(submoduleDep1, sharedDep), (sharedDep, sharedDepTransitive)] graph'
+
+
+spec :: Spec
+spec = do
+  scopeFilters
+  submoduleFilters
\ No newline at end of file
diff --git a/test/Maven/DepTreeSpec.hs b/test/Maven/DepTreeSpec.hs
index 502d4a2ae0..ec7eb962ed 100644
--- a/test/Maven/DepTreeSpec.hs
+++ b/test/Maven/DepTreeSpec.hs
@@ -10,6 +10,7 @@ import DepTypes (
   VerConstraint (..),
  )
 import GraphUtil
+import Graphing (shrinkRoots)
 import Strategy.Maven.Common (MavenDependency (..))
 import Strategy.Maven.DepTree (
   DotGraph (..),
@@ -86,7 +87,9 @@ spec =
       let mavenDepHamcrestCore = MavenDependency depHamcrestCore (Set.fromList ["test"])
 
       -- Act
-      let graph = buildGraph fixtureSingleGraph
+      -- NOTE: Previously shrinkRoots was applied at this level, but it has now been moved upstream to allow for submodule filtering
+      --       Adding shrinkRoots to our buildGraph function to mimic prior behavior
+      let graph = shrinkRoots $ buildGraph fixtureSingleGraph
 
       -- Assert
       expectDeps [mavenDepRngCore, mavenDepMath3, mavenDepJunit, mavenDepRngClientApi, mavenDepHamcrestCore] graph
diff --git a/test/Maven/PluginStrategySpec.hs b/test/Maven/PluginStrategySpec.hs
index 6d67e063a3..f1396664e3 100644
--- a/test/Maven/PluginStrategySpec.hs
+++ b/test/Maven/PluginStrategySpec.hs
@@ -29,6 +29,7 @@ import Strategy.Maven.Plugin (
  )
 import Strategy.Maven.PluginStrategy (buildGraph)
 
+import Graphing (shrinkRoots)
 import Strategy.Maven.Common (MavenDependency (..))
 import Test.Hspec (Spec, describe, it)
 
@@ -275,30 +276,32 @@ mavenCrossDependentSubModules =
 spec :: Spec
 spec = do
   describe "buildGraph" $ do
+    -- NOTE: Previously shrinkRoots was applied at this level, but it has now been moved upstream to allow for submodule filtering
+    --       Adding shrinkRoots to our buildGraph function to mimic prior behavior
     it "should produce expected output" $ do
-      let graph = buildGraph (ReactorOutput []) mavenOutput
+      let graph = shrinkRoots $ buildGraph (ReactorOutput []) mavenOutput
 
       expectDeps [packageOne, packageTwo] graph
       expectDirect [] graph
       expectEdges [(packageOne, packageTwo)] graph
 
     it "Should promote children of root dep(s) to direct" $ do
-      let graph = buildGraph (ReactorOutput []) mavenOutputWithDirects
+      let graph = shrinkRoots $ buildGraph (ReactorOutput []) mavenOutputWithDirects
       expectDeps [packageTwo] graph
       expectDirect [packageTwo] graph
       expectEdges [] graph
 
     it "Should promote children of root dep(s) to direct in multimodule projects" $ do
-      let graph = buildGraph (ReactorOutput []) mavenMultimoduleOutputWithDirects
+      let graph = shrinkRoots $ buildGraph (ReactorOutput []) mavenMultimoduleOutputWithDirects
       expectDeps [packageTwo, packageFour] graph
       expectDirect [packageTwo, packageFour] graph
       expectEdges [] graph
 
     it "Should parse all scopes" $ do
-      let graph = buildGraph (ReactorOutput []) mavenMultiScopeOutput
+      let graph = shrinkRoots $ buildGraph (ReactorOutput []) mavenMultiScopeOutput
       expectDeps [packageMultiScope] graph
 
-    let graph = buildGraph (ReactorOutput [ReactorArtifact "packageThree"]) mavenCrossDependentSubModules
+    let graph = shrinkRoots $ buildGraph (ReactorOutput [ReactorArtifact "packageThree"]) mavenCrossDependentSubModules
     it "Should mark top-level graph artifacts and known submodules as direct, then shrinkRoots" $ do
       expectDirect [packageTwo, packageFour] graph