diff --git a/README.md b/README.md
index 1684b3e..8665dad 100644
--- a/README.md
+++ b/README.md
@@ -95,6 +95,7 @@ envs:
       <application_name>:
         app_deployer: <bootstrap_application>  ## application that will deploy this application
         app_deployer_env: <environment_name>  ## (OPTIONAL) for multi-environments with single ArgoCD deployment
+        non_k8s_files_to_render: [<filename>]  ## (OPTIONAL) list of files to render that are not Kubernetes resources (e.g., values.yml)
         project: <project_name>  ## ArgoCD project name
         destination_namespace: <namespace>  ## default namespace where the application resources will be deployed
 vars:
@@ -136,7 +137,7 @@ vars:
 ```
 
 ### Variables in `config.yml`
-Variables can be referenced in the configuration file (including in the application parameters section) using the following syntax:
+Variables can be referenced in the configuration file using the following syntax:
 ```${var_name}``` and  ```${var_name[dict_key][...]}```.
 
 Variables can also be used as substring values:
@@ -147,7 +148,7 @@ To include file content in the current Jinja2 template, use the following block:
 
 ```
 {%- filter indent(width=4) %}
-{% include_raw 'app_4/files/file.json' %}
+{% include_raw 'files/file.json' %}
 {% endfilter %}
 ```
 
@@ -158,7 +159,7 @@ To render a template in the current jinja2 template, use the following block:
 
 ```
 {%- filter indent(width=4) %}
-{% include 'app_5/files/file.json.j2' %}
+{% include 'files/file.json.j2' %}
 {% endfilter %}
 ```
 
diff --git a/dev_requirements.txt b/dev_requirements.txt
index 6647917..f154119 100644
--- a/dev_requirements.txt
+++ b/dev_requirements.txt
@@ -2,5 +2,6 @@ setuptools
 build==0.10.0
 twine==4.0.2
 pytest==7.4.0
+pytest-asyncio==0.23.8
 yelp-gprof2dot==1.2.0
 flake8==7.0.0
diff --git a/make_argocd_fly/application.py b/make_argocd_fly/application.py
index 49e95a5..ac1fa94 100644
--- a/make_argocd_fly/application.py
+++ b/make_argocd_fly/application.py
@@ -1,21 +1,21 @@
 import logging
 import os
-import asyncio
 from abc import ABC, abstractmethod
 import textwrap
 from pprint import pformat
 
-from make_argocd_fly.resource import ResourceViewer, ResourceWriter
-from make_argocd_fly.renderer import JinjaRenderer
-from make_argocd_fly.utils import multi_resource_parser, resource_parser, merge_dicts, generate_filename, \
-  VarsResolver
+from make_argocd_fly.resource import ResourceViewer
+from make_argocd_fly.utils import merge_dicts, VarsResolver, get_app_rel_path
 from make_argocd_fly.config import get_config
 from make_argocd_fly.cli_args import get_cli_args
+from make_argocd_fly.steps import FindAppsStep, RenderYamlStep, RenderJinjaFromViewerStep, RenderJinjaFromMemoryStep, \
+  WriteResourcesStep, ReadSourceStep, RunKustomizeStep
+from make_argocd_fly.exceptions import MissingSourceResourcesError
 
 log = logging.getLogger(__name__)
 
 
-class AbstractApplication(ABC):
+class AbstractWorkflow(ABC):
   def __init__(self, app_name: str, env_name: str, app_viewer: ResourceViewer = None) -> None:
     super().__init__()
 
@@ -24,20 +24,13 @@ def __init__(self, app_name: str, env_name: str, app_viewer: ResourceViewer = No
     self.app_viewer = app_viewer
     self.config = get_config()
     self.cli_args = get_cli_args()
-    self.resources = None
-
-  async def prepare(self) -> str:
-    pass
 
   @abstractmethod
-  async def generate_resources(self) -> None:
+  async def process(self) -> None:
     pass
 
-  def get_app_rel_path(self) -> str:
-    return os.path.join(self.env_name, self.app_name)
 
-
-class AppOfApps(AbstractApplication):
+class AppOfAppsWorkflow(AbstractWorkflow):
   APPLICATION_RESOUCE_TEMPLATE = '''\
     apiVersion: argoproj.io/v1alpha1
     kind: Application
@@ -68,32 +61,25 @@ class AppOfApps(AbstractApplication):
     '''
 
   def __init__(self, app_name: str, env_name: str, app_viewer: ResourceViewer = None) -> None:
-    self._config = get_config()
     super().__init__(app_name, env_name, app_viewer)
+    self.find_apps_step = FindAppsStep()
+    self.render_jinja_step = RenderJinjaFromMemoryStep()
+    self.write_resources_step = WriteResourcesStep()
 
-    log.debug('Created application {} of type {} for environment {}'.format(app_name, __class__.__name__, env_name))
-
-  def _find_deploying_apps(self, app_deployer_name: str, app_deployer_env_name: str) -> tuple[str, str, str, str]:
-    for env_name, env_data in self._config.get_envs().items():
-      for app_name, app_data in env_data['apps'].items():
-        if 'app_deployer' in app_data and 'project' in app_data and 'destination_namespace' in app_data:
-          if (app_deployer_name == app_data['app_deployer'] and
-              (('app_deployer_env' not in app_data and env_name == app_deployer_env_name) or
-               ('app_deployer_env' in app_data and app_deployer_env_name == app_data['app_deployer_env']))):
-            yield (app_name, env_name, app_data['project'], app_data['destination_namespace'])
+    log.debug('Created application {} with {} for environment {}'.format(app_name, __class__.__name__, env_name))
 
-  async def generate_resources(self) -> None:
-    log.debug('Generating resources for application {} in environment {}'.format(self.app_name, self.env_name))
+  async def process(self) -> None:
+    log.debug('Starting to process application {} in environment {}'.format(self.app_name, self.env_name))
 
-    resources = []
-    renderer = JinjaRenderer()
+    self.find_apps_step.configure(self.app_name, self.env_name)
+    await self.find_apps_step.run()
 
-    for (app_name, env_name, project, destination_namespace) in self._find_deploying_apps(self.app_name, self.env_name):
+    for (app_name, env_name, project, destination_namespace) in self.find_apps_step.get_apps():
       template_vars = VarsResolver.resolve_all(merge_dicts(self.config.get_vars(), self.config.get_env_vars(env_name),
                                                            self.config.get_app_vars(env_name, app_name), {
                                                            '__application': {
                                                              'application_name': '-'.join([os.path.basename(app_name), env_name]).replace('_', '-'),
-                                                             'path': os.path.join(os.path.basename(self._config.get_output_dir()),
+                                                             'path': os.path.join(os.path.basename(self.config.get_output_dir()),
                                                                                   env_name, app_name
                                                                                   ),
                                                              'project': project,
@@ -103,24 +89,28 @@ async def generate_resources(self) -> None:
                                                            'app_name': app_name}),
                                                var_identifier=self.cli_args.get_var_identifier())
 
-      content = renderer.render(textwrap.dedent(self.APPLICATION_RESOUCE_TEMPLATE), template_vars)
-      resources.append(content)
+      self.render_jinja_step.configure(textwrap.dedent(self.APPLICATION_RESOUCE_TEMPLATE), self.app_name, self.env_name, template_vars)
+      await self.render_jinja_step.run()
 
-    self.resources = '\n---\n'.join(resources)
     log.debug('Generated resources for application {} in environment {}'.format(self.app_name, self.env_name))
 
+    self.write_resources_step.configure(self.config.get_output_dir(), self.render_jinja_step.get_resources())
+    await self.write_resources_step.run()
+    log.info('Updated application {} in environment {}'.format(self.app_name, self.env_name))
 
-class Application(AbstractApplication):
+
+class SimpleWorkflow(AbstractWorkflow):
   def __init__(self, app_name: str, env_name: str, app_viewer: ResourceViewer = None) -> None:
     super().__init__(app_name, env_name, app_viewer)
+    self.render_yaml_step = RenderYamlStep()
+    self.render_jinja_step = RenderJinjaFromViewerStep(app_viewer)
+    self.write_resources_step = WriteResourcesStep()
 
-    log.debug('Created application {} of type {} for environment {}'.format(app_name, __class__.__name__, env_name))
+    log.debug('Created application {} with {} for environment {}'.format(app_name, __class__.__name__, env_name))
 
-  async def generate_resources(self) -> None:
-    log.debug('Generating resources for application {} in environment {}'.format(self.app_name, self.env_name))
+  async def process(self) -> None:
+    log.debug('Starting to process application {} in environment {}'.format(self.app_name, self.env_name))
 
-    resources = []
-    renderer = JinjaRenderer(self.app_viewer)
     template_vars = VarsResolver.resolve_all(merge_dicts(self.config.get_vars(), self.config.get_env_vars(self.env_name),
                                                          self.config.get_app_vars(self.env_name, self.app_name),
                                                          {'env_name': self.env_name, 'app_name': self.app_name}),
@@ -128,48 +118,37 @@ async def generate_resources(self) -> None:
     if self.cli_args.get_print_vars():
       log.info('Variables for application {} in environment {}:\n{}'.format(self.app_name, self.env_name, pformat(template_vars)))
 
-    yml_children = self.app_viewer.get_files_children(r'(\.yml|\.yml\.j2)$')
-    for yml_child in yml_children:
-      content = yml_child.content
-      if yml_child.element_rel_path.endswith('.j2'):
-        content = renderer.render(content, template_vars, yml_child.element_rel_path)
+    yml_children = self.app_viewer.get_files_children(r'(\.yml)$')
+    self.render_yaml_step.configure(yml_children, self.app_name, self.env_name)
+    await self.render_yaml_step.run()
 
-      resources.append(content)
+    j2_children = self.app_viewer.get_files_children(r'(\.yml\.j2)$')
+    self.render_jinja_step.configure(j2_children, self.app_name, self.env_name, template_vars)
+    await self.render_jinja_step.run()
 
-    self.resources = '\n---\n'.join(resources)
     log.debug('Generated resources for application {} in environment {}'.format(self.app_name, self.env_name))
 
+    self.write_resources_step.configure(self.config.get_output_dir(), self.render_yaml_step.get_resources() + self.render_jinja_step.get_resources())
+    await self.write_resources_step.run()
+
+    log.info('Updated application {} in environment {}'.format(self.app_name, self.env_name))
+
 
-class KustomizeApplication(AbstractApplication):
+class KustomizeWorkflow(AbstractWorkflow):
   def __init__(self, app_name: str, env_name: str, app_viewer: ResourceViewer = None) -> None:
     super().__init__(app_name, env_name, app_viewer)
+    self.render_yaml_step = RenderYamlStep()
+    self.render_jinja_step = RenderJinjaFromViewerStep(app_viewer)
+    self.tmp_write_resources_step = WriteResourcesStep()
+    self.tmp_read_source_step = ReadSourceStep()
+    self.run_kustomize_step = RunKustomizeStep()
+    self.write_resources_step = WriteResourcesStep()
 
-    log.debug('Created application {} of type {} for environment {}'.format(app_name, __class__.__name__, env_name))
-
-  async def _run_kustomize(self, dir_path: str, retries: int = 3) -> str:
-    for attempt in range(retries):
-      proc = await asyncio.create_subprocess_shell(
-        'kustomize build --enable-helm {}'.format(dir_path),
-        stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.PIPE)
-
-      stdout, stderr = await proc.communicate()
-      if stderr:
-        log.error('Kustomize error: {}'.format(stderr))
-        log.info('Retrying {}/{}'.format(attempt + 1, retries))
-        continue
-      break
-    else:
-      raise Exception('Kustomize execution failed for application {} in environment {}'.format(self.app_name, self.env_name))
-
-    return stdout.decode("utf-8")
+    log.debug('Created application {} with {} for environment {}'.format(app_name, __class__.__name__, env_name))
 
-  async def prepare(self) -> str:
-    config = get_config()
-    tmp_dir = config.get_tmp_dir()
+  async def process(self) -> None:
+    log.debug('Starting to process application {} in environment {}'.format(self.app_name, self.env_name))
 
-    tmp_resource_writer = ResourceWriter(tmp_dir)
-    renderer = JinjaRenderer(self.app_viewer)
     template_vars = VarsResolver.resolve_all(merge_dicts(self.config.get_vars(), self.config.get_env_vars(self.env_name),
                                                          self.config.get_app_vars(self.env_name, self.app_name),
                                                          {'env_name': self.env_name, 'app_name': self.app_name}),
@@ -178,67 +157,54 @@ async def prepare(self) -> str:
     if self.cli_args.get_print_vars():
       log.info('Variables for application {} in environment {}:\n{}'.format(self.app_name, self.env_name, pformat(template_vars)))
 
-    yml_children = self.app_viewer.get_files_children(r'(\.yml|\.yml\.j2)$', ['base', self.env_name])
-    for yml_child in yml_children:
-      content = yml_child.content
-      if yml_child.element_rel_path.endswith('.j2'):
-        try:
-          content = renderer.render(content, template_vars, yml_child.element_rel_path)
-        except Exception as e:
-          log.error('Error rendering template {}: {}'.format(yml_child.element_rel_path, e))
-          raise
-
-      # TODO: (None, None) is not a good way to check if the content is a k8s resource
-      if resource_parser(content) != (None, None):
-        for resource_kind, resource_name, resource_yml in multi_resource_parser(content):
-          file_path = os.path.join(self.env_name, os.path.dirname(yml_child.element_rel_path), generate_filename([resource_kind, resource_name]))
-          tmp_resource_writer.store_resource(file_path, resource_yml)
-      else:
-        file_path = os.path.join(
-          self.env_name, os.path.dirname(yml_child.element_rel_path),
-          generate_filename([os.path.basename(yml_child.element_rel_path.split('.')[0])])
-        )
-        tmp_resource_writer.store_resource(file_path, content)
-
-    await tmp_resource_writer.write_resources()
-
-  async def generate_resources(self) -> None:
-    log.debug('Generating resources for application {} in environment {}'.format(self.app_name, self.env_name))
-
-    config = get_config()
-    tmp_dir = config.get_tmp_dir()
-
-    tmp_source_viewer = ResourceViewer(os.path.join(tmp_dir, self.get_app_rel_path()))
-    tmp_source_viewer.build()
-
-    yml_child = tmp_source_viewer.get_element(os.path.join(self.env_name, 'kustomization.yml'))
-    if yml_child:
-      self.resources = await self._run_kustomize(os.path.join(tmp_source_viewer.root_element_abs_path, os.path.dirname(yml_child.element_rel_path)))
-      log.debug('Generated resources for application {} in environment {}'.format(self.app_name, self.env_name))
-      return
-
-    yml_child = tmp_source_viewer.get_element(os.path.join('base', 'kustomization.yml'))
-    if yml_child:
-      self.resources = await self._run_kustomize(os.path.join(tmp_source_viewer.root_element_abs_path, os.path.dirname(yml_child.element_rel_path)))
-      log.debug('Generated resources for application {} in environment {}'.format(self.app_name, self.env_name))
-      return
-
-    yml_child = tmp_source_viewer.get_element('kustomization.yml')
-    if yml_child:
-      self.resources = await self._run_kustomize(os.path.join(tmp_source_viewer.root_element_abs_path, os.path.dirname(yml_child.element_rel_path)))
-      log.debug('Generated resources for application {} in environment {}'.format(self.app_name, self.env_name))
-      return
-
-    log.error('Missing kustomization.yml in the application directory. Skipping application')
-
-
-def application_factory(app_viewer: ResourceViewer, app_name: str, env_name: str) -> AbstractApplication:
-  if app_viewer:
-    kustomize_children = app_viewer.get_files_children('kustomization.yml')
+    yml_children = self.app_viewer.get_files_children(r'(\.yml)$', ['base', self.env_name])
+    self.render_yaml_step.configure(yml_children, self.app_name, self.env_name)
+    await self.render_yaml_step.run()
+
+    j2_children = self.app_viewer.get_files_children(r'(\.yml\.j2)$', ['base', self.env_name])
+    self.render_jinja_step.configure(j2_children, self.app_name, self.env_name, template_vars)
+    await self.render_jinja_step.run()
+
+    self.tmp_write_resources_step.configure(self.config.get_tmp_dir(), self.render_yaml_step.get_resources() + self.render_jinja_step.get_resources())
+    await self.tmp_write_resources_step.run()
+
+    self.tmp_read_source_step.configure(os.path.join(self.config.get_tmp_dir(), get_app_rel_path(self.app_name, self.env_name)))
+    await self.tmp_read_source_step.run()
+
+    self.run_kustomize_step.configure(self.tmp_read_source_step.get_viewer(), self.app_name, self.env_name)
+    await self.run_kustomize_step.run()
+
+    log.debug('Generated resources for application {} in environment {}'.format(self.app_name, self.env_name))
+
+    self.write_resources_step.configure(self.config.get_output_dir(), self.run_kustomize_step.get_resources())
+    await self.write_resources_step.run()
+
+    log.info('Updated application {} in environment {}'.format(self.app_name, self.env_name))
+
+
+async def workflow_factory(app_name: str, env_name: str, source_path: str) -> AbstractWorkflow:
+  read_source_step = ReadSourceStep()
+  read_source_step.configure(source_path)
+
+  try:
+    await read_source_step.run()
+    viewer = read_source_step.get_viewer()
+
+    kustomize_children = viewer.get_files_children('kustomization.yml')
 
     if not kustomize_children:
-      return Application(app_name, env_name, app_viewer)
+      return SimpleWorkflow(app_name, env_name, viewer)
     else:
-      return KustomizeApplication(app_name, env_name, app_viewer)
-  else:
-    return AppOfApps(app_name, env_name, None)
+      return KustomizeWorkflow(app_name, env_name, viewer)
+  except MissingSourceResourcesError:
+    return AppOfAppsWorkflow(app_name, env_name)
+
+
+class Application():
+  def __init__(self, app_name: str, env_name: str, workflow: AbstractWorkflow) -> None:
+    self.app_name = app_name
+    self.env_name = env_name
+    self.workflow = workflow
+
+  async def process(self) -> None:
+    await self.workflow.process()
diff --git a/make_argocd_fly/config.py b/make_argocd_fly/config.py
index 2527a0d..1b4149b 100644
--- a/make_argocd_fly/config.py
+++ b/make_argocd_fly/config.py
@@ -41,13 +41,13 @@ def get_tmp_dir(self) -> str:
     return get_abs_path(self.root_dir, self.tmp_dir, allow_missing=True)
 
   def get_envs(self) -> dict:
-    if not self.envs:
+    if not isinstance(self.envs, dict):
       log.error('Config was not initialized.')
       raise Exception
     return self.envs
 
   def get_vars(self) -> dict:
-    if not self.envs:
+    if not isinstance(self.vars, dict):
       log.error('Config was not initialized.')
       raise Exception
     return self.vars
@@ -71,6 +71,23 @@ def get_app_vars(self, env_name: str, app_name: str) -> dict:
 
     return envs[env_name]['apps'][app_name]['vars'] if 'vars' in envs[env_name]['apps'][app_name] else {}
 
+  def get_app_params(self, env_name: str, app_name: str) -> dict:
+    envs = self.get_envs()
+    if env_name not in envs:
+      log.error('Environment {} is not defined'.format(env_name))
+      raise Exception
+
+    if app_name not in envs[env_name]['apps']:
+      log.error('Application {} is not defined in environment {}'.format(app_name, env_name))
+      raise Exception
+
+    params = {}
+    for key, value in envs[env_name]['apps'][app_name].items():
+      if key != 'vars':
+        params[key] = value
+
+    return params
+
 
 config = Config()
 
diff --git a/make_argocd_fly/exceptions.py b/make_argocd_fly/exceptions.py
new file mode 100644
index 0000000..440da40
--- /dev/null
+++ b/make_argocd_fly/exceptions.py
@@ -0,0 +1,2 @@
+class MissingSourceResourcesError(Exception):
+  pass
diff --git a/make_argocd_fly/main.py b/make_argocd_fly/main.py
index 82b4e5b..5aa5c65 100644
--- a/make_argocd_fly/main.py
+++ b/make_argocd_fly/main.py
@@ -11,9 +11,8 @@
 from make_argocd_fly.cli_args import populate_cli_args, get_cli_args
 from make_argocd_fly.config import read_config, get_config, LOG_CONFIG_FILE, CONFIG_FILE, \
   SOURCE_DIR, OUTPUT_DIR, TMP_DIR
-from make_argocd_fly.utils import multi_resource_parser, generate_filename, latest_version_check
-from make_argocd_fly.resource import ResourceViewer, ResourceWriter
-from make_argocd_fly.application import application_factory
+from make_argocd_fly.utils import latest_version_check
+from make_argocd_fly.application import workflow_factory, Application
 
 
 logging.basicConfig(level='INFO')
@@ -32,12 +31,11 @@ def init_logging(loglevel: str) -> None:
     pass
 
 
-def create_applications(render_apps, render_envs):
+async def generate() -> None:
   config = get_config()
-
-  log.info('Reading source directory')
-  source_viewer = ResourceViewer(config.get_source_dir())
-  source_viewer.build()
+  cli_args = get_cli_args()
+  render_apps = cli_args.get_render_apps()
+  render_envs = cli_args.get_render_envs()
 
   apps_to_render = render_apps.split(',') if render_apps is not None else []
   envs_to_render = render_envs.split(',') if render_envs is not None else []
@@ -52,47 +50,17 @@ def create_applications(render_apps, render_envs):
       if apps_to_render and app_name not in apps_to_render:
         continue
 
-      app_viewer = source_viewer.get_element(app_name)
-      apps.append(application_factory(app_viewer, app_name, env_name))
-
-  return apps
-
-
-async def generate() -> None:
-  cli_args = get_cli_args()
-  config = get_config()
-
-  apps = create_applications(cli_args.get_render_apps(), cli_args.get_render_envs())
+      workflow = await workflow_factory(app_name, env_name, os.path.join(config.get_source_dir(), app_name))
+      apps.append(Application(app_name, env_name, workflow))
 
+  log.info('Processing applications')
   try:
-    log.info('Generating temporary files')
-    await asyncio.gather(*[asyncio.create_task(app.prepare()) for app in apps])
-
-    log.info('Rendering resources')
-    await asyncio.gather(*[asyncio.create_task(app.generate_resources()) for app in apps])
+    await asyncio.gather(*[asyncio.create_task(app.process()) for app in apps])
   except Exception:
     for task in asyncio.all_tasks():
       task.cancel()
     raise
 
-  output_writer = ResourceWriter(config.get_output_dir())
-  for app in apps:
-    for resource_kind, resource_name, resource_yml in multi_resource_parser(app.resources):
-      file_path = os.path.join(app.get_app_rel_path(), generate_filename([resource_kind, resource_name]))
-      output_writer.store_resource(file_path, resource_yml)
-
-  if apps:
-    log.info('The following applications have been updated:')
-    for app in apps:
-      app_dir = os.path.join(config.get_output_dir(), app.get_app_rel_path())
-      log.info('Environment: {}, Application: {}, Path: {}'.format(app.env_name, app.app_name, app_dir))
-      if os.path.exists(app_dir):
-        shutil.rmtree(app_dir)
-
-  log.info('Writing resources files')
-  os.makedirs(config.get_output_dir(), exist_ok=True)
-  await output_writer.write_resources()
-
 
 def main() -> None:
   parser = argparse.ArgumentParser(description='Render ArgoCD Applications.')
diff --git a/make_argocd_fly/renderer.py b/make_argocd_fly/renderer.py
index c1b4c8a..00788a4 100644
--- a/make_argocd_fly/renderer.py
+++ b/make_argocd_fly/renderer.py
@@ -13,7 +13,7 @@
 
 class AbstractRenderer(ABC):
   @abstractmethod
-  def render(self, content: str, template_vars: dict = None) -> str:
+  def render(self, content: str) -> str:
     pass
 
 
@@ -21,7 +21,7 @@ class DummyRenderer(AbstractRenderer):
   def __init__(self) -> None:
     pass
 
-  def render(self, content: str, template_vars: dict = None) -> str:
+  def render(self, content: str) -> str:
     return content
 
 
@@ -63,6 +63,9 @@ def __init__(self, viewer: ResourceViewer = None) -> None:
                                        'jinja2_ansible_filters.AnsibleCoreFiltersExtension'],
                            loader=self.loader, undefined=StrictUndefined)
 
+    self.template_vars = {}
+    self.filename = '<template>'
+
   def _get_template(self, path: str):
     files_children = self.viewer.get_files_children(os.path.basename(path))
     for file_child in files_children:
@@ -72,8 +75,14 @@ def _get_template(self, path: str):
     log.error('Missing template {}'.format(path))
     return None
 
-  def render(self, content: str, template_vars: dict = None, filename: str = '<template>') -> str:
+  def set_template_vars(self, template_vars: dict) -> None:
+    self.template_vars = template_vars
+
+  def set_filename(self, filename: str) -> None:
+    self.filename = filename
+
+  def render(self, content: str) -> str:
     template = self.env.from_string(content)
-    template.filename = filename
+    template.filename = self.filename
 
-    return template.render(template_vars if template_vars else {})
+    return template.render(self.template_vars)
diff --git a/make_argocd_fly/resource.py b/make_argocd_fly/resource.py
index 9947651..2f29cd1 100644
--- a/make_argocd_fly/resource.py
+++ b/make_argocd_fly/resource.py
@@ -3,11 +3,14 @@
 import re
 import asyncio
 import yaml
+import yaml.composer
 try:
   from yaml import CSafeLoader as SafeLoader
 except ImportError:
   from yaml import SafeLoader
 
+from make_argocd_fly.exceptions import MissingSourceResourcesError
+
 log = logging.getLogger(__name__)
 
 
@@ -29,10 +32,6 @@ def str_presenter(dumper, data):
 
 class ResourceViewer:
   def __init__(self, root_element_abs_path: str, element_rel_path: str = '.', is_dir: bool = True) -> None:
-    if not os.path.exists(root_element_abs_path):
-      log.error('Path does not exist {}'.format(root_element_abs_path))
-      raise Exception
-
     self.root_element_abs_path = root_element_abs_path
     self.element_rel_path = os.path.normpath(element_rel_path)
     self.is_dir = is_dir
@@ -46,6 +45,9 @@ def __init__(self, root_element_abs_path: str, element_rel_path: str = '.', is_d
     self.children = []
 
   def build(self) -> None:
+    if not os.path.exists(self.root_element_abs_path):
+      raise MissingSourceResourcesError('Path does not exist {}'.format(self.root_element_abs_path))
+
     path = os.path.join(self.root_element_abs_path, self.element_rel_path)
     if not os.path.exists(path):
       log.error('Path does not exist {}'.format(path))
@@ -137,7 +139,13 @@ async def _write_resource(self, file_path: str, resource_yml: str) -> None:
 
     with open(os.path.join(self.output_dir_abs_path, file_path), 'w') as f:
       f.write(resource_yml)
-    yaml_obj = yaml.load(resource_yml, Loader=SafeLoader)
+
+    try:
+      yaml_obj = yaml.load(resource_yml, Loader=SafeLoader)
+    except yaml.composer.ComposerError:
+      log.error('Error parsing yaml to write as file {}. Yaml:\n{}'.format(file_path, resource_yml))
+      raise
+
     with open(os.path.join(self.output_dir_abs_path, file_path), 'w') as f:
       yaml.dump(yaml_obj, f, Dumper=SafeDumper,
                 default_flow_style=False,
@@ -152,4 +160,6 @@ async def write_resources(self) -> None:
         *[asyncio.create_task(self._write_resource(file_path, resource_yml)) for file_path, resource_yml in self.resources.items()]
       )
     except Exception:
+      for task in asyncio.all_tasks():
+        task.cancel()
       raise
diff --git a/make_argocd_fly/steps.py b/make_argocd_fly/steps.py
new file mode 100644
index 0000000..48e4aa7
--- /dev/null
+++ b/make_argocd_fly/steps.py
@@ -0,0 +1,235 @@
+import logging
+import os
+import asyncio
+from abc import ABC, abstractmethod
+
+from make_argocd_fly.config import get_config
+from make_argocd_fly.renderer import DummyRenderer, JinjaRenderer
+from make_argocd_fly.resource import ResourceViewer, ResourceWriter
+from make_argocd_fly.utils import extract_single_resource, get_filename_elements, generate_filename, get_app_rel_path
+
+log = logging.getLogger(__name__)
+
+
+class AbstractStep(ABC):
+    @abstractmethod
+    async def run(self) -> None:
+        pass
+
+
+class FindAppsStep(AbstractStep):
+  def __init__(self) -> None:
+    self.config = get_config()
+    self.apps = []
+
+  def configure(self, app_deployer_name: str, app_deployer_env_name: str) -> None:
+    self.app_deployer_name = app_deployer_name
+    self.app_deployer_env_name = app_deployer_env_name
+
+  async def run(self) -> None:
+    if not self.app_deployer_name or not self.app_deployer_env_name:
+      log.error('Step is not configured')
+      raise
+
+    for env_name, env_data in self.config.get_envs().items():
+      if 'apps' not in env_data:
+        log.error('No apps defined in environment {}'.format(env_name))
+        continue
+
+      for app_name in env_data['apps'].keys():
+        app_params = self.config.get_app_params(env_name, app_name)
+
+        if 'app_deployer' in app_params and 'project' in app_params and 'destination_namespace' in app_params:
+          if (self.app_deployer_name == app_params['app_deployer'] and
+              (('app_deployer_env' not in app_params and env_name == self.app_deployer_env_name) or
+               ('app_deployer_env' in app_params and self.app_deployer_env_name == app_params['app_deployer_env']))):
+            self.apps.append((app_name, env_name, app_params['project'], app_params['destination_namespace']))
+
+  def get_apps(self) -> list:
+    return self.apps
+
+
+class BaseResourceGenerationStep(AbstractStep):
+  def __init__(self) -> None:
+    self.resources = []
+
+  def _generate_file_path(self, resource_yml: str, source_filename: str = None, element_rel_path: str = '.') -> str:
+    filename_elements = get_filename_elements(resource_yml)
+    if not filename_elements:
+      app_params = get_config().get_app_params(self.env_name, self.app_name)
+      if source_filename and 'non_k8s_files_to_render' in app_params and source_filename in app_params['non_k8s_files_to_render']:
+        filename_elements = [os.path.basename(source_filename.split('.')[0])]
+      else:
+        raise ValueError("Filename elements could not be determined")
+
+    return os.path.join(
+      get_app_rel_path(self.app_name, self.env_name),
+      os.path.dirname(element_rel_path),
+      generate_filename(filename_elements)
+    )
+
+  def get_resources(self) -> list:
+    return self.resources
+
+
+class RenderYamlStep(BaseResourceGenerationStep):
+  def __init__(self) -> None:
+    super().__init__()
+    self.renderer = DummyRenderer()
+
+  def configure(self, yml_children: list, app_name: str, env_name: str) -> None:
+    self.yml_children = yml_children
+    self.app_name = app_name
+    self.env_name = env_name
+
+  async def run(self) -> None:
+    for yml_child in self.yml_children:
+      try:
+        result = self.renderer.render(yml_child.content)
+
+        for resource_yml in extract_single_resource(result):
+          try:
+            file_path = self._generate_file_path(resource_yml, yml_child.name, yml_child.element_rel_path)
+            self.resources.append((file_path, resource_yml))
+          except ValueError:
+            pass
+      except Exception as e:
+        log.error('Error rendering yaml: {}'.format(e))
+        raise
+
+
+class RenderJinjaFromViewerStep(BaseResourceGenerationStep):
+  def __init__(self, viewer: ResourceViewer) -> None:
+    super().__init__()
+    self.renderer = JinjaRenderer(viewer)
+
+  def configure(self, j2_children: list, app_name: str, env_name: str, vars: dict = {}) -> None:
+    self.j2_children = j2_children
+    self.app_name = app_name
+    self.env_name = env_name
+    self.vars = vars
+
+  async def run(self) -> None:
+    for j2_child in self.j2_children:
+      try:
+        self.renderer.set_template_vars(self.vars)
+        self.renderer.set_filename(j2_child.element_rel_path)
+        result = self.renderer.render(j2_child.content)
+
+        for resource_yml in extract_single_resource(result):
+          try:
+            file_path = self._generate_file_path(resource_yml, j2_child.name, j2_child.element_rel_path)
+            self.resources.append((file_path, resource_yml))
+          except ValueError:
+            pass
+      except Exception as e:
+        log.error('Error rendering template {}: {}'.format(j2_child.element_rel_path, e))
+        raise
+
+
+class RenderJinjaFromMemoryStep(BaseResourceGenerationStep):
+  def __init__(self) -> None:
+    super().__init__()
+    self.renderer = JinjaRenderer()
+
+  def configure(self, template: str, app_name: str, env_name: str, vars: dict = {}) -> None:
+    self.template = template
+    self.app_name = app_name
+    self.env_name = env_name
+    self.vars = vars
+
+  async def run(self) -> None:
+    try:
+      self.renderer.set_template_vars(self.vars)
+      result = self.renderer.render(self.template)
+
+      for resource_yml in extract_single_resource(result):
+        try:
+          file_path = self._generate_file_path(resource_yml)
+          self.resources.append((file_path, resource_yml))
+        except ValueError:
+          pass
+    except Exception as e:
+      log.error('Error rendering template: {}'.format(e))
+      raise
+
+
+class RunKustomizeStep(BaseResourceGenerationStep):
+  def __init__(self) -> None:
+    super().__init__()
+    self.dir_path = None
+
+  def configure(self, viewer: ResourceViewer, app_name: str, env_name: str) -> None:
+    self.viewer = viewer
+    self.app_name = app_name
+    self.env_name = env_name
+
+    kustomization_children = self.viewer.get_files_children('kustomization.yml')
+    kustomization_locations = [
+      os.path.join(self.env_name, 'kustomization.yml'),
+      os.path.join('base', 'kustomization.yml'),
+      'kustomization.yml'
+    ]
+    for location in kustomization_locations:
+      if location in [child.element_rel_path for child in kustomization_children]:
+        self.dir_path = os.path.join(self.viewer.root_element_abs_path, os.path.dirname(location))
+        break
+    else:
+      log.error('Missing kustomization.yml in the application directory. Skipping application')
+
+  async def run(self) -> None:
+    retries = 3
+
+    if not self.dir_path:
+      log.error('Step is not configured')
+      raise
+
+    for attempt in range(retries):
+      proc = await asyncio.create_subprocess_shell(
+        'kustomize build --enable-helm {}'.format(self.dir_path),
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE)
+
+      stdout, stderr = await proc.communicate()
+      if stderr:
+        log.error('Kustomize error: {}'.format(stderr))
+        log.info('Retrying {}/{}'.format(attempt + 1, retries))
+        continue
+      break
+    else:
+      raise Exception('Kustomize execution failed for application {} in environment {}'.format(self.app_name, self.env_name))
+
+    for resource_yml in extract_single_resource(stdout.decode("utf-8")):
+      try:
+        file_path = self._generate_file_path(resource_yml)
+        self.resources.append((file_path, resource_yml))
+      except ValueError:
+        pass
+
+
+class WriteResourcesStep(AbstractStep):
+  def __init__(self) -> None:
+    pass
+
+  def configure(self, output_dir_abs_path: str, resources_to_write: list) -> None:
+    self.writer = ResourceWriter(output_dir_abs_path)
+
+    for path, content in resources_to_write:
+      self.writer.store_resource(path, content)
+
+  async def run(self) -> None:
+    await self.writer.write_resources()
+
+
+class ReadSourceStep(AbstractStep):
+  def __init__(self) -> None:
+    pass
+
+  def configure(self, input_dir_abs_path: str) -> None:
+    self.viewer = ResourceViewer(input_dir_abs_path)
+
+  async def run(self) -> None:
+    self.viewer.build()
+
+  def get_viewer(self) -> ResourceViewer:
+    return self.viewer
diff --git a/make_argocd_fly/utils.py b/make_argocd_fly/utils.py
index 0601359..68f282e 100644
--- a/make_argocd_fly/utils.py
+++ b/make_argocd_fly/utils.py
@@ -1,5 +1,6 @@
 import logging
 import re
+import os
 import copy
 import ast
 import json
@@ -90,14 +91,15 @@ def resolve_all(vars: dict, var_identifier: str = '$') -> dict:
       return resolved_vars
 
 
-# TODO: rename this, logic does not align with multi_resource_parser
-def resource_parser(resource_yml: str) -> tuple[str, str]:
+def get_filename_elements(resource_yml: str) -> list:
+  filename_elements = []
   resource_kind = None
   resource_name = None
 
   match = re.search(r'(^kind:|\nkind:)(.+)', resource_yml)
   if match:
     resource_kind = match.group(2).strip()
+    filename_elements.append(resource_kind)
 
   if resource_kind:
     match = re.search(r'(^metadata:|\nmetadata:).*', resource_yml)
@@ -105,25 +107,29 @@ def resource_parser(resource_yml: str) -> tuple[str, str]:
       match = re.search(r'(^\s\sname:|\n\s\sname:)(.+)', resource_yml[match.start():])
       if match:
         resource_name = match.group(2).strip()
+        filename_elements.append(resource_name)
 
-  return (resource_kind, resource_name)
+  return filename_elements
 
 
-def multi_resource_parser(multi_resource_yml: str) -> tuple[str, str, str]:
+def extract_single_resource(multi_resource_yml: str) -> str:
   for resource_yml in multi_resource_yml.split('\n---\n'):
     resource_yml = resource_yml.strip().lstrip('---\n')
-    (resource_kind, resource_name) = resource_parser(resource_yml)
 
-    if resource_kind:
-      yield (resource_kind, resource_name, resource_yml)
+    if resource_yml:
+      yield resource_yml
 
 
 def generate_filename(filename_parts: list) -> str:
-    if not filename_parts:
-      log.error('Filename cannot be constructed')
-      raise Exception
+  if not filename_parts:
+    log.error('Filename cannot be constructed')
+    raise Exception
 
-    return '_'.join([filename_part for filename_part in filename_parts if filename_part]).lower() + '.yml'
+  return '_'.join([filename_part for filename_part in filename_parts if filename_part]).lower() + '.yml'
+
+
+def get_app_rel_path(app_name: str, env_name: str) -> str:
+  return os.path.join(env_name, app_name)
 
 
 def merge_dicts(*dicts):
diff --git a/tests/manual/config.yml b/tests/manual/config.yml
index 791e044..caf5c0b 100644
--- a/tests/manual/config.yml
+++ b/tests/manual/config.yml
@@ -37,7 +37,7 @@ envs:
       subdirectory_2/app_8: {app_deployer: service_deployer, project: management, destination_namespace: kube-default}
       app_9: {app_deployer: service_deployer, project: management, destination_namespace: kube-default}
       app_10: {app_deployer: service_deployer, project: management, destination_namespace: kube-default}
-      app_11: {app_deployer: service_deployer, project: management, destination_namespace: kube-default}
+      app_11: {app_deployer: service_deployer, non_k8s_files_to_render: ['values.yml.j2'], project: management, destination_namespace: kube-default}
       app_12: {vars: {version: 1.1.1}}
     vars:
       argocd:
diff --git a/tests/manual/output/management/app_4/Deployment_thanos-sidecar-2.yml b/tests/manual/output/management/app_4/Deployment_thanos-sidecar-2.yml
index 6673bed..99ec06b 100644
--- a/tests/manual/output/management/app_4/Deployment_thanos-sidecar-2.yml
+++ b/tests/manual/output/management/app_4/Deployment_thanos-sidecar-2.yml
@@ -9,3 +9,5 @@ data: |-
     "test": "jsoninclude",
     "test_2": "{{ variable }}"
   }
+data_2: 'hello: world'
+data_3: 'hello: kube-default'
diff --git a/tests/manual/source/app_4/deployment.yml.j2 b/tests/manual/source/app_4/deployment.yml.j2
index 4952d80..14f5926 100644
--- a/tests/manual/source/app_4/deployment.yml.j2
+++ b/tests/manual/source/app_4/deployment.yml.j2
@@ -13,5 +13,15 @@ metadata:
   namespace: {{ namespace }}
 data: |-
 {%- filter indent(width=4) %}
-{% include_raw 'app_4/files/file.json' %}
+{% include_raw 'files/file.json' %}
+{% endfilter %}
+
+data_2: |-
+{%- filter indent(width=4) %}
+{% include_raw 'files/file_2.yml' %}
+{% endfilter %}
+
+data_3: |-
+{%- filter indent(width=4) %}
+{% include 'files/file_3.yml.j2' %}
 {% endfilter %}
diff --git a/tests/manual/source/app_4/files/file_2.yml b/tests/manual/source/app_4/files/file_2.yml
new file mode 100644
index 0000000..bb56b05
--- /dev/null
+++ b/tests/manual/source/app_4/files/file_2.yml
@@ -0,0 +1 @@
+hello: world
diff --git a/tests/manual/source/app_4/files/file_3.yml.j2 b/tests/manual/source/app_4/files/file_3.yml.j2
new file mode 100644
index 0000000..20559e9
--- /dev/null
+++ b/tests/manual/source/app_4/files/file_3.yml.j2
@@ -0,0 +1 @@
+hello: {{ namespace }}
diff --git a/tests/manual/source/app_5/configmap.yml.j2 b/tests/manual/source/app_5/configmap.yml.j2
index 1da8073..57ff3de 100644
--- a/tests/manual/source/app_5/configmap.yml.j2
+++ b/tests/manual/source/app_5/configmap.yml.j2
@@ -6,7 +6,7 @@ metadata:
 data:
   prometheus.yml: |-
 {%- filter indent(width=4) %}
-{% include 'app_5/files/file.json.j2' %}
+{% include 'files/file.json.j2' %}
 {% endfilter %}
 
   ip: {{ 'localhost' | dig }}
diff --git a/tests/test_application.py b/tests/test_application.py
index aed3fae..9b9afab 100644
--- a/tests/test_application.py
+++ b/tests/test_application.py
@@ -1,10 +1,10 @@
 import pytest
 
-from make_argocd_fly.application import application_factory, Application, KustomizeApplication, AppOfApps
-from make_argocd_fly.resource import ResourceViewer
+from make_argocd_fly.application import workflow_factory, AppOfAppsWorkflow, SimpleWorkflow, KustomizeWorkflow
 
 
-def test_application_factory_create_Application(tmp_path):
+@pytest.mark.asyncio
+async def test_workflow_factory_create_SimpleWorkflow(tmp_path):
   dir_root = tmp_path / 'dir_root'
   dir_root.mkdir()
   dir_app = dir_root / 'app'
@@ -13,17 +13,14 @@ def test_application_factory_create_Application(tmp_path):
   file_app = dir_app / 'resource.yml'
   file_app.write_text(FILE_CONTENT)
 
-  resource_viewer = ResourceViewer(str(dir_root))
-  resource_viewer.build()
-
   app_name = 'app'
   env_name = 'env'
 
-  app_instance = application_factory(resource_viewer, app_name, env_name)
-
-  assert isinstance(app_instance, Application)
+  app_instance = await workflow_factory(app_name, env_name, str(dir_app))
+  assert isinstance(app_instance, SimpleWorkflow)
 
-def test_application_factory_create_KustomizeApplication(tmp_path):
+@pytest.mark.asyncio
+async def test_workflow_factory_create_KustomizeWorkflow(tmp_path):
   dir_root = tmp_path / 'dir_root'
   dir_root.mkdir()
   dir_app = dir_root / 'app'
@@ -32,20 +29,16 @@ def test_application_factory_create_KustomizeApplication(tmp_path):
   file_app = dir_app / 'kustomization.yml'
   file_app.write_text(FILE_CONTENT)
 
-  resource_viewer = ResourceViewer(str(dir_root))
-  resource_viewer.build()
-
   app_name = 'app'
   env_name = 'env'
 
-  app_instance = application_factory(resource_viewer, app_name, env_name)
+  app_instance = await workflow_factory(app_name, env_name, str(dir_app))
+  assert isinstance(app_instance, KustomizeWorkflow)
 
-  assert isinstance(app_instance, KustomizeApplication)
-
-def test_application_factory_create_AppOfApps(tmp_path):
+@pytest.mark.asyncio
+async def test_application_factory_create_AppOfApps():
   app_name = 'app'
   env_name = 'env'
 
-  app_instance = application_factory(None, app_name, env_name)
-
-  assert isinstance(app_instance, AppOfApps)
+  app_instance = await workflow_factory(app_name, env_name, 'non_existing_dir')
+  assert isinstance(app_instance, AppOfAppsWorkflow)
diff --git a/tests/test_renderer.py b/tests/test_renderer.py
index 1bfc6fd..9a1003f 100644
--- a/tests/test_renderer.py
+++ b/tests/test_renderer.py
@@ -64,7 +64,8 @@ def test_JinjaRenderer_base_loader_render_with_var():
   Template content {{ line_2 }}
   '''
 
-  assert renderer.render(TEMPLATE, {'line_2': 'line 2'}) == \
+  renderer.set_template_vars({'line_2': 'line 2'})
+  assert renderer.render(TEMPLATE) == \
   '''\
   Template content line 1
   Template content line 2
@@ -101,13 +102,13 @@ def test_JinjaRenderer_function_loader_render_with_include_raw(tmp_path):
   template_0 = dir_0 / 'template.txt.j2'
   template_0.write_text(TEMPLATE_0)
 
-  resource_viewer = ResourceViewer(str(dir_root))
+  resource_viewer = ResourceViewer(str(dir_0))
   resource_viewer.build()
   renderer = JinjaRenderer(resource_viewer)
 
   TEMPLATE = '''\
   Template content line 1
-  {% include_raw 'dir_0/template.txt.j2' %}
+  {% include_raw 'template.txt.j2' %}
   '''
 
   assert renderer.render(TEMPLATE) == \
@@ -125,16 +126,17 @@ def test_JinjaRenderer_function_loader_render_with_include(tmp_path):
   template_0 = dir_0 / 'template.txt.j2'
   template_0.write_text(TEMPLATE_0)
 
-  resource_viewer = ResourceViewer(str(dir_root))
+  resource_viewer = ResourceViewer(str(dir_0))
   resource_viewer.build()
   renderer = JinjaRenderer(resource_viewer)
 
   TEMPLATE = '''\
   Template content line 1
-  {% include 'dir_0/template.txt.j2' %}
+  {% include 'template.txt.j2' %}
   '''
 
-  assert renderer.render(TEMPLATE, {'content': 'content 0'}) == \
+  renderer.set_template_vars({'content': 'content 0'})
+  assert renderer.render(TEMPLATE) == \
   '''\
   Template content line 1
   Template content 0
@@ -145,23 +147,24 @@ def test_JinjaRenderer_function_loader_render_with_include_inception(tmp_path):
   dir_root.mkdir()
   dir_0 = dir_root / 'dir_0'
   dir_0.mkdir()
-  TEMPLATE_0 = "{% include 'dir_0/template_inception.txt.j2' %}"
+  TEMPLATE_0 = "{% include 'template_inception.txt.j2' %}"
   template_0 = dir_0 / 'template.txt.j2'
   template_0.write_text(TEMPLATE_0)
   TEMPLATE_1 = 'Template {{ content }}'
   template_1 = dir_0 / 'template_inception.txt.j2'
   template_1.write_text(TEMPLATE_1)
 
-  resource_viewer = ResourceViewer(str(dir_root))
+  resource_viewer = ResourceViewer(str(dir_0))
   resource_viewer.build()
   renderer = JinjaRenderer(resource_viewer)
 
   TEMPLATE = '''\
   Template content line 1
-  {% include 'dir_0/template.txt.j2' %}
+  {% include 'template.txt.j2' %}
   '''
 
-  assert renderer.render(TEMPLATE, {'content': 'content 0'}) == \
+  renderer.set_template_vars({'content': 'content 0'})
+  assert renderer.render(TEMPLATE) == \
   '''\
   Template content line 1
   Template content 0
diff --git a/tests/test_resource.py b/tests/test_resource.py
index 5531f9a..d51119c 100644
--- a/tests/test_resource.py
+++ b/tests/test_resource.py
@@ -1,5 +1,6 @@
 import pytest
 from make_argocd_fly.resource import ResourceViewer, ResourceWriter
+from make_argocd_fly.exceptions import MissingSourceResourcesError
 
 ##################
 ### ResourceViewer
@@ -58,12 +59,13 @@ def test_ResourceViewer_constructor_with_non_normalized_path(tmp_path):
   assert resource_viewer.content is None
   assert resource_viewer.children == []
 
-def test_ResourceViewer_constructor_with_non_existing_path(caplog):
-  with pytest.raises(Exception):
-      ResourceViewer('/non/existing/path')
-  assert 'Path does not exist' in caplog.text
+def test_ResourceViewer_build_with_non_existing_root_path(caplog):
+  resource_viewer = ResourceViewer('/non/existing/path')
+
+  with pytest.raises(MissingSourceResourcesError):
+    resource_viewer.build()
 
-def test_ResourceViewer_build_with_non_existing_path(tmp_path, caplog):
+def test_ResourceViewer_build_with_non_existing_child_path(tmp_path, caplog):
   dir_root = tmp_path / 'dir_root'
   dir_root.mkdir()
   element_path = 'other_element'
diff --git a/tests/test_steps.py b/tests/test_steps.py
new file mode 100644
index 0000000..77db96e
--- /dev/null
+++ b/tests/test_steps.py
@@ -0,0 +1,144 @@
+import pytest
+import textwrap
+
+from make_argocd_fly.steps import FindAppsStep
+from make_argocd_fly.config import read_config
+from make_argocd_fly.cli_args import populate_cli_args
+
+###################
+### FindAppsStep
+###################
+
+@pytest.fixture
+def find_apps_step():
+  return FindAppsStep()
+
+# @pytest.fixture
+# def get_config():
+
+def test_find_apps_step_configure(find_apps_step):
+  app_deployer_name = "my_app_deployer"
+  app_deployer_env_name = "my_env"
+
+  find_apps_step.configure(app_deployer_name, app_deployer_env_name)
+
+  assert find_apps_step.app_deployer_name == app_deployer_name
+  assert find_apps_step.app_deployer_env_name == app_deployer_env_name
+
+def test_find_apps_step_get_apps(find_apps_step):
+  apps = find_apps_step.get_apps()
+
+  assert isinstance(apps, list)
+  assert len(apps) == 0
+
+@pytest.mark.asyncio
+async def test_find_apps_step_run_single_app_same_env(tmp_path):
+  CONFIG = '''\
+  envs:
+    test_env:
+      apps:
+        bootstrap: {}
+        app_1:
+          app_deployer: bootstrap
+          project: my_project
+          destination_namespace: my_namespace
+  '''
+
+  root_dir = tmp_path
+  config_file = tmp_path / 'config.yml'
+  config_file.write_text(textwrap.dedent(CONFIG))
+  source_dir = tmp_path / 'source'
+  source_dir.mkdir()
+  cli_args = populate_cli_args(root_dir=root_dir, config_file=config_file, source_dir=source_dir, output_dir='output', tmp_dir='.tmp')
+  read_config(root_dir, config_file, cli_args)
+
+  app_deployer_name = "bootstrap"
+  app_deployer_env_name = "test_env"
+  find_apps_step = FindAppsStep()
+  find_apps_step.configure(app_deployer_name, app_deployer_env_name)
+
+  await find_apps_step.run()
+  apps = find_apps_step.get_apps()
+
+  assert isinstance(apps, list)
+  assert len(apps) == 1
+  assert ('app_1', 'test_env', 'my_project', 'my_namespace') in apps
+
+@pytest.mark.asyncio
+async def test_find_apps_step_run_multiple_apps_same_env(tmp_path):
+  CONFIG = '''\
+  envs:
+    test_env:
+      apps:
+        bootstrap: {}
+        app_1:
+          app_deployer: bootstrap
+          project: my_project
+          destination_namespace: my_namespace
+        app_2:
+          app_deployer: bootstrap
+          project: my_project
+          destination_namespace: my_namespace
+  '''
+
+  root_dir = tmp_path
+  config_file = tmp_path / 'config.yml'
+  config_file.write_text(textwrap.dedent(CONFIG))
+  source_dir = tmp_path / 'source'
+  source_dir.mkdir()
+  cli_args = populate_cli_args(root_dir=root_dir, config_file=config_file, source_dir=source_dir, output_dir='output', tmp_dir='.tmp')
+  read_config(root_dir, config_file, cli_args)
+
+  app_deployer_name = "bootstrap"
+  app_deployer_env_name = "test_env"
+  find_apps_step = FindAppsStep()
+  find_apps_step.configure(app_deployer_name, app_deployer_env_name)
+
+  await find_apps_step.run()
+  apps = find_apps_step.get_apps()
+
+  assert isinstance(apps, list)
+  assert len(apps) == 2
+  assert ('app_1', 'test_env', 'my_project', 'my_namespace') in apps
+  assert ('app_2', 'test_env', 'my_project', 'my_namespace') in apps
+
+@pytest.mark.asyncio
+async def test_find_apps_step_run_multiple_apps_different_envs(tmp_path):
+  CONFIG = '''\
+  envs:
+    test_env:
+      apps:
+        bootstrap: {}
+        app_1:
+          app_deployer: bootstrap
+          project: my_project
+          destination_namespace: my_namespace
+    test_env_2:
+      apps:
+        app_2:
+          app_deployer: bootstrap
+          app_deployer_env: test_env
+          project: my_project
+          destination_namespace: my_namespace
+  '''
+
+  root_dir = tmp_path
+  config_file = tmp_path / 'config.yml'
+  config_file.write_text(textwrap.dedent(CONFIG))
+  source_dir = tmp_path / 'source'
+  source_dir.mkdir()
+  cli_args = populate_cli_args(root_dir=root_dir, config_file=config_file, source_dir=source_dir, output_dir='output', tmp_dir='.tmp')
+  read_config(root_dir, config_file, cli_args)
+
+  app_deployer_name = "bootstrap"
+  app_deployer_env_name = "test_env"
+  find_apps_step = FindAppsStep()
+  find_apps_step.configure(app_deployer_name, app_deployer_env_name)
+
+  await find_apps_step.run()
+  apps = find_apps_step.get_apps()
+
+  assert isinstance(apps, list)
+  assert len(apps) == 2
+  assert ('app_1', 'test_env', 'my_project', 'my_namespace') in apps
+  assert ('app_2', 'test_env_2', 'my_project', 'my_namespace') in apps
diff --git a/tests/test_utils.py b/tests/test_utils.py
index fc18e2b..92c556f 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -1,12 +1,18 @@
 import pytest
 import textwrap
 
-from make_argocd_fly.utils import resource_parser, multi_resource_parser, generate_filename, merge_dicts, VarsResolver
+from make_argocd_fly.utils import get_filename_elements, extract_single_resource, generate_filename, merge_dicts, VarsResolver
 
 ###################
-### resource_parser
+### get_filename_elements
 ###################
 
+def test_resource_parser_empty():
+  resource_yml = '''\
+    '''
+
+  assert get_filename_elements(textwrap.dedent(resource_yml)) == []
+
 def test_resource_parser_simple():
   resource_yml = '''\
     apiVersion: apps/v1
@@ -15,7 +21,7 @@ def test_resource_parser_simple():
       name: grafana
     '''
 
-  assert resource_parser(textwrap.dedent(resource_yml)) == ('Deployment', 'grafana')
+  assert get_filename_elements(textwrap.dedent(resource_yml)) == ['Deployment', 'grafana']
 
 def test_resource_parser_missing_name():
   resource_yml = '''\
@@ -25,7 +31,7 @@ def test_resource_parser_missing_name():
       namespace: monitoring
     '''
 
-  assert resource_parser(textwrap.dedent(resource_yml)) == ('Deployment', None)
+  assert get_filename_elements(textwrap.dedent(resource_yml)) == ['Deployment']
 
 def test_resource_parser_with_comments():
   resource_yml = '''\
@@ -38,7 +44,7 @@ def test_resource_parser_with_comments():
       name: grafana
     '''
 
-  assert resource_parser(textwrap.dedent(resource_yml)) == ('Deployment', 'grafana')
+  assert get_filename_elements(textwrap.dedent(resource_yml)) == ['Deployment', 'grafana']
 
 def test_resource_parser_with_leading_comments():
   resource_yml = '''\
@@ -51,7 +57,7 @@ def test_resource_parser_with_leading_comments():
       name: grafana
     '''
 
-  assert resource_parser(textwrap.dedent(resource_yml)) == ('Deployment', 'grafana')
+  assert get_filename_elements(textwrap.dedent(resource_yml)) == ['Deployment', 'grafana']
 
 def test_resource_parser_with_comments_and_leading_kind():
   resource_yml = '''\
@@ -64,7 +70,7 @@ def test_resource_parser_with_comments_and_leading_kind():
       name: grafana
     '''
 
-  assert resource_parser(textwrap.dedent(resource_yml)) == ('Deployment', 'grafana')
+  assert get_filename_elements(textwrap.dedent(resource_yml)) == ['Deployment', 'grafana']
 
 def test_resource_parser_with_messed_up_order_metadata_at_the_beginning():
   resource_yml = '''\
@@ -76,7 +82,7 @@ def test_resource_parser_with_messed_up_order_metadata_at_the_beginning():
       name: notgrafana
     '''
 
-  assert resource_parser(textwrap.dedent(resource_yml)) == ('Deployment', 'grafana')
+  assert get_filename_elements(textwrap.dedent(resource_yml)) == ['Deployment', 'grafana']
 
 def test_resource_parser_with_messed_up_order_metadata_in_the_middle():
   resource_yml = '''\
@@ -88,7 +94,7 @@ def test_resource_parser_with_messed_up_order_metadata_in_the_middle():
       name: grafana
     '''
 
-  assert resource_parser(textwrap.dedent(resource_yml)) == ('Deployment', 'grafana')
+  assert get_filename_elements(textwrap.dedent(resource_yml)) == ['Deployment', 'grafana']
 
 def test_resource_parser_with_messed_up_order_name_extra_spaces():
   resource_yml = '''\
@@ -100,7 +106,7 @@ def test_resource_parser_with_messed_up_order_name_extra_spaces():
         name: grafana
     '''
 
-  assert resource_parser(textwrap.dedent(resource_yml)) == ('Deployment', None)
+  assert get_filename_elements(textwrap.dedent(resource_yml)) == ['Deployment']
 
 def test_resource_parser_with_messed_up_order_name_is_not_first():
   resource_yml = '''\
@@ -113,7 +119,7 @@ def test_resource_parser_with_messed_up_order_name_is_not_first():
       name: grafana
     '''
 
-  assert resource_parser(textwrap.dedent(resource_yml)) == ('Deployment', 'grafana')
+  assert get_filename_elements(textwrap.dedent(resource_yml)) == ['Deployment', 'grafana']
 
 def test_resource_parser_with_messed_up_order_name_is_not_first_with_comment_1():
   resource_yml = '''\
@@ -127,7 +133,7 @@ def test_resource_parser_with_messed_up_order_name_is_not_first_with_comment_1()
       name: grafana
     '''
 
-  assert resource_parser(textwrap.dedent(resource_yml)) == ('Deployment', 'grafana')
+  assert get_filename_elements(textwrap.dedent(resource_yml)) == ['Deployment', 'grafana']
 
 def test_resource_parser_with_messed_up_order_name_is_not_first_with_comments_2():
   resource_yml = '''\
@@ -141,7 +147,7 @@ def test_resource_parser_with_messed_up_order_name_is_not_first_with_comments_2(
       name: grafana
     '''
 
-  assert resource_parser(textwrap.dedent(resource_yml)) == ('Deployment', 'grafana')
+  assert get_filename_elements(textwrap.dedent(resource_yml)) == ['Deployment', 'grafana']
 
 def test_resource_parser_with_messed_up_order_name_is_not_first_with_comments_3():
   resource_yml = '''\
@@ -155,7 +161,7 @@ def test_resource_parser_with_messed_up_order_name_is_not_first_with_comments_3(
       name: grafana
     '''
 
-  assert resource_parser(textwrap.dedent(resource_yml)) == ('Deployment', 'grafana')
+  assert get_filename_elements(textwrap.dedent(resource_yml)) == ['Deployment', 'grafana']
 
 def test_resource_parser_with_messed_up_order_name_is_not_first_with_comments_4():
   resource_yml = '''\
@@ -169,10 +175,10 @@ def test_resource_parser_with_messed_up_order_name_is_not_first_with_comments_4(
       name: grafana
     '''
 
-  assert resource_parser(textwrap.dedent(resource_yml)) == ('Deployment', 'grafana')
+  assert get_filename_elements(textwrap.dedent(resource_yml)) == ['Deployment', 'grafana']
 
 ###################
-### multi_resource_parser
+### extract_single_resource
 ###################
 
 def test_multi_resource_parser_with_valid_yaml():
@@ -187,10 +193,10 @@ def test_multi_resource_parser_with_valid_yaml():
       name: prometheus
     '''
 
-  result = list(multi_resource_parser(textwrap.dedent(multi_resource_yml)))
+  result = list(extract_single_resource(textwrap.dedent(multi_resource_yml)))
   expected = [
-      ('Deployment', 'grafana', 'kind: Deployment\nmetadata:\n  name: grafana'),
-      ('DaemonSet', 'prometheus', 'kind: DaemonSet\nmetadata:\n  name: prometheus')
+      ('kind: Deployment\nmetadata:\n  name: grafana'),
+      ('kind: DaemonSet\nmetadata:\n  name: prometheus')
   ]
 
   assert result == expected
@@ -208,10 +214,10 @@ def test_multi_resource_parser_with_valid_yaml_extra_separator_at_the_top():
       name: prometheus
     '''
 
-  result = list(multi_resource_parser(textwrap.dedent(multi_resource_yml)))
+  result = list(extract_single_resource(textwrap.dedent(multi_resource_yml)))
   expected = [
-      ('Deployment', 'grafana', 'kind: Deployment\nmetadata:\n  name: grafana'),
-      ('DaemonSet', 'prometheus', 'kind: DaemonSet\nmetadata:\n  name: prometheus')
+      ('kind: Deployment\nmetadata:\n  name: grafana'),
+      ('kind: DaemonSet\nmetadata:\n  name: prometheus')
   ]
 
   assert result == expected
@@ -229,10 +235,10 @@ def test_multi_resource_parser_with_valid_yaml_extra_separator_at_the_bottom():
     ---
     '''
 
-  result = list(multi_resource_parser(textwrap.dedent(multi_resource_yml)))
+  result = list(extract_single_resource(textwrap.dedent(multi_resource_yml)))
   expected = [
-      ('Deployment', 'grafana', 'kind: Deployment\nmetadata:\n  name: grafana'),
-      ('DaemonSet', 'prometheus', 'kind: DaemonSet\nmetadata:\n  name: prometheus')
+      ('kind: Deployment\nmetadata:\n  name: grafana'),
+      ('kind: DaemonSet\nmetadata:\n  name: prometheus')
   ]
 
   assert result == expected
@@ -250,10 +256,10 @@ def test_multi_resource_parser_with_valid_yaml_not_an_extra_separator():
       name: prometheus
     '''
 
-  result = list(multi_resource_parser(textwrap.dedent(multi_resource_yml)))
+  result = list(extract_single_resource(textwrap.dedent(multi_resource_yml)))
   expected = [
-      ('Deployment', 'grafana', 'kind: Deployment\nmetadata:\n  name: grafana\n  comment: "--- This is not an extra separator"'),
-      ('DaemonSet', 'prometheus', 'kind: DaemonSet\nmetadata:\n  name: prometheus')
+      ('kind: Deployment\nmetadata:\n  name: grafana\n  comment: "--- This is not an extra separator"'),
+      ('kind: DaemonSet\nmetadata:\n  name: prometheus')
   ]
 
   assert result == expected
@@ -272,10 +278,10 @@ def test_multi_resource_parser_with_valid_yaml_not_an_extra_separator_2():
       name: prometheus
     '''
 
-  result = list(multi_resource_parser(textwrap.dedent(multi_resource_yml)))
+  result = list(extract_single_resource(textwrap.dedent(multi_resource_yml)))
   expected = [
-      ('Deployment', 'grafana', 'kind: Deployment\nmetadata:\n  name: grafana\n  comment: |\n    This is not an extra separator ----'),
-      ('DaemonSet', 'prometheus', 'kind: DaemonSet\nmetadata:\n  name: prometheus')
+      ('kind: Deployment\nmetadata:\n  name: grafana\n  comment: |\n    This is not an extra separator ----'),
+      ('kind: DaemonSet\nmetadata:\n  name: prometheus')
   ]
 
   assert result == expected