diff --git a/packages/frontend/app/components/learner-group/calendar.gjs b/packages/frontend/app/components/learner-group/calendar.gjs
index bc0a708abe..dca235d5ad 100644
--- a/packages/frontend/app/components/learner-group/calendar.gjs
+++ b/packages/frontend/app/components/learner-group/calendar.gjs
@@ -3,7 +3,6 @@ import { cached, tracked } from '@glimmer/tracking';
 import { action } from '@ember/object';
 import { service } from '@ember/service';
 import { DateTime } from 'luxon';
-import { map } from 'rsvp';
 import { mapBy } from 'ilios-common/utils/array-helpers';
 import { TrackedAsyncData } from 'ember-async-data';
 import ToggleYesno from 'ilios-common/components/toggle-yesno';
@@ -68,36 +67,38 @@ export default class LearnerGroupCalendarComponent extends Component {
     const flat = offerings.reduce((flattened, obj) => {
       return [...flattened, ...obj];
     }, []);
-    return await map(flat, async (offering) => {
-      const session = await offering.session;
-      const sessionType = await session.sessionType;
-      const course = await session.course;
-      const school = await course.school;
-      const instructors = await offering.getAllInstructors();
-      const instructorNames = instructors.map((instructor) => instructor.fullName);
+    return await Promise.all(
+      flat.map(async (offering) => {
+        const session = await offering.session;
+        const sessionType = await session.sessionType;
+        const course = await session.course;
+        const school = await course.school;
+        const instructors = await offering.getAllInstructors();
+        const instructorNames = instructors.map((instructor) => instructor.fullName);
 
-      return new Event(
-        {
-          startDate: offering.startDate.toISOString(),
-          endDate: offering.endDate.toISOString(),
-          lastModified: offering.updatedAt.toISOString(),
-          courseTitle: course.title,
-          name: session.title,
-          offering: offering.id,
-          location: offering.room,
-          school: school.id,
-          color: sessionType.calendarColor,
-          prerequisites: [],
-          postrequisites: [],
-          isScheduled: session.isScheduled || course.isScheduled,
-          isPublished: session.isPublished && course.isPublished,
-          sessionTypeTitle: sessionType.title,
-          instructors: instructorNames,
-        },
-        false,
-        showAsBlockedTime,
-      );
-    });
+        return new Event(
+          {
+            startDate: offering.startDate.toISOString(),
+            endDate: offering.endDate.toISOString(),
+            lastModified: offering.updatedAt.toISOString(),
+            courseTitle: course.title,
+            name: session.title,
+            offering: offering.id,
+            location: offering.room,
+            school: school.id,
+            color: sessionType.calendarColor,
+            prerequisites: [],
+            postrequisites: [],
+            isScheduled: session.isScheduled || course.isScheduled,
+            isPublished: session.isPublished && course.isPublished,
+            sessionTypeTitle: sessionType.title,
+            instructors: instructorNames,
+          },
+          false,
+          showAsBlockedTime,
+        );
+      }),
+    );
   }
 
   @action
diff --git a/packages/frontend/app/components/learner-group/list-item.gjs b/packages/frontend/app/components/learner-group/list-item.gjs
index ac5b576a43..41074c437c 100644
--- a/packages/frontend/app/components/learner-group/list-item.gjs
+++ b/packages/frontend/app/components/learner-group/list-item.gjs
@@ -2,7 +2,7 @@ import Component from '@glimmer/component';
 import { cached, tracked } from '@glimmer/tracking';
 import { action } from '@ember/object';
 import { task } from 'ember-concurrency';
-import { filter, map } from 'rsvp';
+import { filter } from 'rsvp';
 import { TrackedAsyncData } from 'ember-async-data';
 import { service } from '@ember/service';
 import { LinkTo } from '@ember/routing';
@@ -107,7 +107,7 @@ export default class LearnerGroupListItemComponent extends Component {
   }
 
   async getSortedTitlesOfSubgroupsInNeedOfAccommodation(groups) {
-    const titles = await map(groups, (group) => group.getTitleWithParentTitles());
+    const titles = await Promise.all(groups.map((group) => group.getTitleWithParentTitles()));
     return titles.sort().join(', ');
   }
 
diff --git a/packages/frontend/app/components/learner-group/root.gjs b/packages/frontend/app/components/learner-group/root.gjs
index bb50263290..2eea80fce8 100644
--- a/packages/frontend/app/components/learner-group/root.gjs
+++ b/packages/frontend/app/components/learner-group/root.gjs
@@ -3,7 +3,6 @@ import { cached, tracked } from '@glimmer/tracking';
 import { action } from '@ember/object';
 import ObjectProxy from '@ember/object/proxy';
 import { service } from '@ember/service';
-import { map } from 'rsvp';
 import { task } from 'ember-concurrency';
 import pad from 'pad';
 import { TrackedAsyncData } from 'ember-async-data';
@@ -322,15 +321,17 @@ export default class LearnerGroupRootComponent extends Component {
     const allDescendants = await topLevelGroup.getAllDescendants();
     const treeGroups = [topLevelGroup, ...allDescendants];
     const users = await learnerGroup.getUsersOnlyAtThisLevel();
-    return await map(users, async (user) => {
-      const lowestGroupInTree = await user.getLowestMemberGroupInALearnerGroupTree(treeGroups);
-      return ObjectProxy.create({
-        content: user,
-        lowestGroupInTree,
-        //special sorting property
-        lowestGroupInTreeTitle: lowestGroupInTree.title,
-      });
-    });
+    return await Promise.all(
+      users.map(async (user) => {
+        const lowestGroupInTree = await user.getLowestMemberGroupInALearnerGroupTree(treeGroups);
+        return ObjectProxy.create({
+          content: user,
+          lowestGroupInTree,
+          //special sorting property
+          lowestGroupInTreeTitle: lowestGroupInTree.title,
+        });
+      }),
+    );
   }
 
   @cached
@@ -353,15 +354,17 @@ export default class LearnerGroupRootComponent extends Component {
     const allDescendants = await topLevelGroup.getAllDescendants();
     const treeGroups = [topLevelGroup, ...allDescendants];
     const users = await topLevelGroup.getAllDescendantUsers();
-    return await map(users, async (user) => {
-      const lowestGroupInTree = await user.getLowestMemberGroupInALearnerGroupTree(treeGroups);
-      return ObjectProxy.create({
-        content: user,
-        lowestGroupInTree,
-        //special sorting property
-        lowestGroupInTreeTitle: lowestGroupInTree.title,
-      });
-    });
+    return await Promise.all(
+      users.map(async (user) => {
+        const lowestGroupInTree = await user.getLowestMemberGroupInALearnerGroupTree(treeGroups);
+        return ObjectProxy.create({
+          content: user,
+          lowestGroupInTree,
+          //special sorting property
+          lowestGroupInTreeTitle: lowestGroupInTree.title,
+        });
+      }),
+    );
   }
 
   @cached
diff --git a/packages/frontend/app/components/learner-group/upload-data.gjs b/packages/frontend/app/components/learner-group/upload-data.gjs
index 3ccfd25597..055c7d0800 100644
--- a/packages/frontend/app/components/learner-group/upload-data.gjs
+++ b/packages/frontend/app/components/learner-group/upload-data.gjs
@@ -1,6 +1,5 @@
 import Component from '@glimmer/component';
 import { service } from '@ember/service';
-import { map } from 'rsvp';
 import { task, timeout } from 'ember-concurrency';
 import PapaParse from 'papaparse';
 import { cached, tracked } from '@glimmer/tracking';
@@ -92,9 +91,8 @@ export default class LearnerGroupUploadDataComponent extends Component {
 
   async parseFile(proposedUsers) {
     const cohort = await this.args.learnerGroup.cohort;
-    const data = await map(
-      proposedUsers,
-      async ({ firstName, lastName, campusId, subGroupName }) => {
+    const data = await Promise.all(
+      proposedUsers.map(async ({ firstName, lastName, campusId, subGroupName }) => {
         const errors = [];
         const warnings = [];
         if (!firstName) {
@@ -175,7 +173,7 @@ export default class LearnerGroupUploadDataComponent extends Component {
           hasWarning: warnings.length > 0,
           isValid: errors.length === 0,
         };
-      },
+      }),
     );
 
     // flag duplicate users as such
diff --git a/packages/frontend/app/components/learner-groups/root.gjs b/packages/frontend/app/components/learner-groups/root.gjs
index 17930f37ba..dee2af73c3 100644
--- a/packages/frontend/app/components/learner-groups/root.gjs
+++ b/packages/frontend/app/components/learner-groups/root.gjs
@@ -6,7 +6,6 @@ import { TrackedAsyncData } from 'ember-async-data';
 import { findById, findBy, sortBy } from 'ilios-common/utils/array-helpers';
 import cloneLearnerGroup from '../../utils/clone-learner-group';
 import { task } from 'ember-concurrency';
-import { map } from 'rsvp';
 import { action } from '@ember/object';
 import FaIcon from '@fortawesome/ember-fontawesome/components/fa-icon';
 import { eq, gt, not } from 'ember-truth-helpers';
@@ -243,32 +242,36 @@ export default class LearnerGroupsRootComponent extends Component {
     if (!programs) {
       return null;
     }
-    const sortingPrograms = await map(programs, async (program) => {
-      const thisYear = new Date().getFullYear();
-      const programYears = await program.programYears;
-      const sorters = await map(programYears, async (programYear) => {
-        const groupCount = (await programYear.cohort).hasMany('learnerGroups').ids().length;
-        return {
-          distanceFromThisYear: thisYear - Number(programYear.startYear),
-          groupCount,
-        };
-      });
-      return sorters.reduce(
-        (obj, sorter) => {
-          if (sorter.distanceFromThisYear < obj.distance) {
-            obj.distance = sorter.distanceFromThisYear;
-          }
-          obj.totalGroups += sorter.groupCount;
-          return obj;
-        },
-        {
-          title: program.title,
-          program,
-          totalGroups: 0,
-          distance: 100,
-        },
-      );
-    });
+    const sortingPrograms = await Promise.all(
+      programs.map(async (program) => {
+        const thisYear = new Date().getFullYear();
+        const programYears = await program.programYears;
+        const sorters = await Promise.all(
+          programYears.map(async (programYear) => {
+            const groupCount = (await programYear.cohort).hasMany('learnerGroups').ids().length;
+            return {
+              distanceFromThisYear: thisYear - Number(programYear.startYear),
+              groupCount,
+            };
+          }),
+        );
+        return sorters.reduce(
+          (obj, sorter) => {
+            if (sorter.distanceFromThisYear < obj.distance) {
+              obj.distance = sorter.distanceFromThisYear;
+            }
+            obj.totalGroups += sorter.groupCount;
+            return obj;
+          },
+          {
+            title: program.title,
+            program,
+            totalGroups: 0,
+            distance: 100,
+          },
+        );
+      }),
+    );
     const sorted = sortingPrograms.sort((a, b) => {
       if (a.distance !== b.distance) {
         return a.distance - b.distance;
diff --git a/packages/frontend/app/components/program-year/competencies.gjs b/packages/frontend/app/components/program-year/competencies.gjs
index 4958c93d1d..ad44b8e6ab 100644
--- a/packages/frontend/app/components/program-year/competencies.gjs
+++ b/packages/frontend/app/components/program-year/competencies.gjs
@@ -1,5 +1,5 @@
 import Component from '@glimmer/component';
-import { filter, map } from 'rsvp';
+import { filter } from 'rsvp';
 import { task, timeout } from 'ember-concurrency';
 import { service } from '@ember/service';
 import { TrackedAsyncData } from 'ember-async-data';
@@ -84,7 +84,7 @@ export default class ProgramYearCompetenciesComponent extends Component {
     const program = await programYear.program;
     const school = await program.school;
     const competencies = await school.competencies;
-    const domains = await map(competencies, async (c) => c.getDomain());
+    const domains = await Promise.all(competencies.map(async (c) => c.getDomain()));
     const programYearCompetencies = await programYear.competencies;
 
     return { program, school, competencies, domains, programYearCompetencies };
diff --git a/packages/frontend/app/components/program-year/objective-list-item-expanded.gjs b/packages/frontend/app/components/program-year/objective-list-item-expanded.gjs
index 822baadbac..25edff0773 100644
--- a/packages/frontend/app/components/program-year/objective-list-item-expanded.gjs
+++ b/packages/frontend/app/components/program-year/objective-list-item-expanded.gjs
@@ -2,7 +2,6 @@ import Component from '@glimmer/component';
 import { cached } from '@glimmer/tracking';
 import { htmlSafe } from '@ember/template';
 import { TrackedAsyncData } from 'ember-async-data';
-import { map } from 'rsvp';
 import { findById } from 'ilios-common/utils/array-helpers';
 import t from 'ember-intl/helpers/t';
 import sortBy from 'ilios-common/helpers/sort-by';
@@ -24,15 +23,17 @@ export default class ProgramYearObjectiveListItemExpandedComponent extends Compo
 
   async getCourseObjects(programYearObjective) {
     const courseObjectives = await programYearObjective.courseObjectives;
-    const objectiveObjects = await map(courseObjectives, async (courseObjective) => {
-      const course = await courseObjective.course;
-      return {
-        title: courseObjective.title,
-        courseId: course.id,
-        courseTitle: course.title,
-        courseExternalId: course.externalId,
-      };
-    });
+    const objectiveObjects = await Promise.all(
+      courseObjectives.map(async (courseObjective) => {
+        const course = await courseObjective.course;
+        return {
+          title: courseObjective.title,
+          courseId: course.id,
+          courseTitle: course.title,
+          courseExternalId: course.externalId,
+        };
+      }),
+    );
     return objectiveObjects.reduce((set, obj) => {
       let existing = findById(set, obj.courseId);
       if (!existing) {
diff --git a/packages/frontend/app/components/program-year/objective-list.gjs b/packages/frontend/app/components/program-year/objective-list.gjs
index dcbbbc2e18..d91575339b 100644
--- a/packages/frontend/app/components/program-year/objective-list.gjs
+++ b/packages/frontend/app/components/program-year/objective-list.gjs
@@ -1,7 +1,6 @@
 import Component from '@glimmer/component';
 import { cached, tracked } from '@glimmer/tracking';
 import { task, timeout } from 'ember-concurrency';
-import { map } from 'rsvp';
 import { service } from '@ember/service';
 import { TrackedAsyncData } from 'ember-async-data';
 import { mapBy, uniqueValues } from 'ilios-common/utils/array-helpers';
@@ -72,19 +71,21 @@ export default class ProgramYearObjectiveListComponent extends Component {
     });
     const parents = await Promise.all(mapBy(programYearCompetencies, 'parent'));
     const allDomains = uniqueValues([...domains, ...parents]).filter(Boolean);
-    return await map(allDomains, async (domain) => {
-      const competencies = (await domain.children).map((competency) => {
+    return await Promise.all(
+      allDomains.map(async (domain) => {
+        const competencies = (await domain.children).map((competency) => {
+          return {
+            id: competency.id,
+            title: competency.title,
+          };
+        });
         return {
-          id: competency.id,
-          title: competency.title,
+          id: domain.id,
+          title: domain.title,
+          competencies,
         };
-      });
-      return {
-        id: domain.id,
-        title: domain.title,
-        competencies,
-      };
-    });
+      }),
+    );
   }
 
   downloadReport = task({ drop: true }, async () => {
diff --git a/packages/frontend/app/components/school/competencies-list.gjs b/packages/frontend/app/components/school/competencies-list.gjs
index c5b432cfec..93c1afb988 100644
--- a/packages/frontend/app/components/school/competencies-list.gjs
+++ b/packages/frontend/app/components/school/competencies-list.gjs
@@ -1,7 +1,6 @@
 import Component from '@glimmer/component';
 import { cached } from '@glimmer/tracking';
 import { TrackedAsyncData } from 'ember-async-data';
-import { map } from 'rsvp';
 import { sortBy } from 'ilios-common/utils/array-helpers';
 import t from 'ember-intl/helpers/t';
 import CompetenciesListItem from './competencies-list-item';
@@ -17,13 +16,15 @@ export default class SchoolCompetenciesListComponent extends Component {
   }
 
   async loadData(domains) {
-    return map(sortBy(domains, 'title'), async (domain) => {
-      const competencies = await domain.children;
-      return {
-        domain,
-        competencies: sortBy(competencies, 'title'),
-      };
-    });
+    return Promise.all(
+      sortBy(domains, 'title').map(async (domain) => {
+        const competencies = await domain.children;
+        return {
+          domain,
+          competencies: sortBy(competencies, 'title'),
+        };
+      }),
+    );
   }
   <template>
     <div class="school-competencies-list" data-test-school-competencies-list ...attributes>
diff --git a/packages/frontend/app/components/school/visualize-session-type-vocabularies-graph.gjs b/packages/frontend/app/components/school/visualize-session-type-vocabularies-graph.gjs
index bb907b944e..24a399732e 100644
--- a/packages/frontend/app/components/school/visualize-session-type-vocabularies-graph.gjs
+++ b/packages/frontend/app/components/school/visualize-session-type-vocabularies-graph.gjs
@@ -1,7 +1,6 @@
 import Component from '@glimmer/component';
 import { service } from '@ember/service';
 import { htmlSafe } from '@ember/template';
-import { map } from 'rsvp';
 import { task, timeout } from 'ember-concurrency';
 import { cached, tracked } from '@glimmer/tracking';
 import { action } from '@ember/object';
@@ -83,23 +82,24 @@ export default class SchoolVisualizeSessionTypeVocabulariesGraphComponent extend
       return [];
     }
 
-    const sessionsWithTerms = await map(sessions, async (session) => {
-      const terms = await session.terms;
-      return terms.map((term) => {
-        return { session, term };
-      });
-    });
+    const sessionsWithTerms = await Promise.all(
+      sessions.map(async (session) => {
+        const terms = await session.terms;
+        return terms.map((term) => {
+          return { session, term };
+        });
+      }),
+    );
 
-    const termsWithSessionAndVocabulary = await map(
-      sessionsWithTerms.flat(),
-      async ({ session, term }) => {
+    const termsWithSessionAndVocabulary = await Promise.all(
+      sessionsWithTerms.flat().map(async ({ session, term }) => {
         const vocabulary = await term.vocabulary;
         return {
           term,
           session,
           vocabulary,
         };
-      },
+      }),
     );
 
     const vocabularyObjects = termsWithSessionAndVocabulary.reduce(
diff --git a/packages/frontend/app/components/school/visualize-session-type-vocabulary-graph.gjs b/packages/frontend/app/components/school/visualize-session-type-vocabulary-graph.gjs
index c5af6d6655..3f17345c28 100644
--- a/packages/frontend/app/components/school/visualize-session-type-vocabulary-graph.gjs
+++ b/packages/frontend/app/components/school/visualize-session-type-vocabulary-graph.gjs
@@ -1,7 +1,7 @@
 import Component from '@glimmer/component';
 import { service } from '@ember/service';
 import { htmlSafe } from '@ember/template';
-import { filter, map } from 'rsvp';
+import { filter } from 'rsvp';
 import { task, timeout } from 'ember-concurrency';
 import { cached, tracked } from '@glimmer/tracking';
 import { TrackedAsyncData } from 'ember-async-data';
@@ -79,21 +79,23 @@ export default class SchoolVisualizeSessionTypeVocabularyGraphComponent extends
       return [];
     }
 
-    const termsWithSession = await map(sessions, async (session) => {
-      const sessionTerms = await session.terms;
+    const termsWithSession = await Promise.all(
+      sessions.map(async (session) => {
+        const sessionTerms = await session.terms;
 
-      const terms = await filter(sessionTerms, async (term) => {
-        const termVocab = await term.vocabulary;
-        return termVocab.id === vocabulary.id;
-      });
+        const terms = await filter(sessionTerms, async (term) => {
+          const termVocab = await term.vocabulary;
+          return termVocab.id === vocabulary.id;
+        });
 
-      return terms.map((term) => {
-        return {
-          term,
-          session,
-        };
-      });
-    });
+        return terms.map((term) => {
+          return {
+            term,
+            session,
+          };
+        });
+      }),
+    );
 
     const termObjects = termsWithSession
       .filter((termsWithSession) => termsWithSession.length)
@@ -112,19 +114,21 @@ export default class SchoolVisualizeSessionTypeVocabularyGraphComponent extends
 
     const termData = Object.values(termObjects);
 
-    const rhett = await map(termData, async (obj) => {
-      const termTitle = await obj.term.getTitleWithParentTitles();
-      return {
-        data: obj.sessionIds.size,
-        label: termTitle,
-        description: this.intl.t('general.termXappliedToYSessionsWithSessionTypeZ', {
-          term: termTitle,
-          vocabulary: vocabulary.title,
-          sessionsCount: obj.sessionIds.size,
-          sessionType: sessionType.title,
-        }),
-      };
-    });
+    const rhett = await Promise.all(
+      termData.map(async (obj) => {
+        const termTitle = await obj.term.getTitleWithParentTitles();
+        return {
+          data: obj.sessionIds.size,
+          label: termTitle,
+          description: this.intl.t('general.termXappliedToYSessionsWithSessionTypeZ', {
+            term: termTitle,
+            vocabulary: vocabulary.title,
+            sessionsCount: obj.sessionIds.size,
+            sessionType: sessionType.title,
+          }),
+        };
+      }),
+    );
     return rhett.sort((first, second) => {
       return first.data - second.data;
     });
diff --git a/packages/frontend/app/components/visualizer-program-year-objectives.gjs b/packages/frontend/app/components/visualizer-program-year-objectives.gjs
index 7a84a36bb4..ad259d1ca5 100644
--- a/packages/frontend/app/components/visualizer-program-year-objectives.gjs
+++ b/packages/frontend/app/components/visualizer-program-year-objectives.gjs
@@ -1,6 +1,6 @@
 import Component from '@glimmer/component';
 import { htmlSafe } from '@ember/template';
-import { filter, map } from 'rsvp';
+import { filter } from 'rsvp';
 import { task, timeout } from 'ember-concurrency';
 import { cached, tracked } from '@glimmer/tracking';
 import { service } from '@ember/service';
@@ -55,15 +55,19 @@ export default class VisualizerProgramYearObjectivesComponent extends Component
     };
     const buildTree = async function (programYearObjective) {
       const courseObjectives = await programYearObjective.courseObjectives;
-      const courseObjectivesTree = await map(courseObjectives, async (courseObjective) => {
-        const sessionObjectives = await courseObjective.sessionObjectives;
-        const sessionObjectivesTree = await map(sessionObjectives, async (sessionObjective) => {
-          const session = await sessionObjective.session;
-          return buildTreeLevel(sessionObjective, [], session.title, null);
-        });
-        const course = await courseObjective.course;
-        return buildTreeLevel(courseObjective, sessionObjectivesTree, null, course.title);
-      });
+      const courseObjectivesTree = await Promise.all(
+        courseObjectives.map(async (courseObjective) => {
+          const sessionObjectives = await courseObjective.sessionObjectives;
+          const sessionObjectivesTree = await Promise.all(
+            sessionObjectives.map(async (sessionObjective) => {
+              const session = await sessionObjective.session;
+              return buildTreeLevel(sessionObjective, [], session.title, null);
+            }),
+          );
+          const course = await courseObjective.course;
+          return buildTreeLevel(courseObjective, sessionObjectivesTree, null, course.title);
+        }),
+      );
       return buildTreeLevel(programYearObjective, courseObjectivesTree, null, null);
     };
     const objectives = await programYear.programYearObjectives;
@@ -71,35 +75,41 @@ export default class VisualizerProgramYearObjectivesComponent extends Component
       const competency = await objective.competency;
       return !!competency;
     });
-    return await map(objectivesWithCompetency, async (objective) => {
-      const obj = await buildTree(objective);
-      const competency = await objective.competency;
-      obj.competencyId = competency.id;
-      return obj;
-    });
+    return await Promise.all(
+      objectivesWithCompetency.map(async (objective) => {
+        const obj = await buildTree(objective);
+        const competency = await objective.competency;
+        obj.competencyId = competency.id;
+        return obj;
+      }),
+    );
   }
 
   async getCompetencyObjects(programYear) {
     const objectiveObjects = await this.getObjectiveObjects(programYear);
     const competencies = await programYear.competencies;
-    return await map(competencies, async (competency) => {
-      const domain = await competency.getDomain();
-
-      const domainId = domain.id;
-      const competencyId = competency.id;
-      const competencyTitle = competency.title;
-      return {
-        domainId,
-        name: competencyTitle,
-        children: filterBy(objectiveObjects, 'competencyId', competencyId),
-      };
-    });
+    return await Promise.all(
+      competencies.map(async (competency) => {
+        const domain = await competency.getDomain();
+
+        const domainId = domain.id;
+        const competencyId = competency.id;
+        const competencyTitle = competency.title;
+        return {
+          domainId,
+          name: competencyTitle,
+          children: filterBy(objectiveObjects, 'competencyId', competencyId),
+        };
+      }),
+    );
   }
 
   async getDomainObjects(programYear) {
     const competencies = await programYear.competencies;
     const competencyObjects = await this.getCompetencyObjects(programYear);
-    const domains = await map(competencies, async (competency) => competency.getDomain());
+    const domains = await Promise.all(
+      competencies.map(async (competency) => competency.getDomain()),
+    );
     return uniqueValues(domains).map((domain) => {
       const id = domain.id;
       const name = domain.title;
diff --git a/packages/frontend/app/utils/clone-learner-group.js b/packages/frontend/app/utils/clone-learner-group.js
index 092e84d6cb..5feb1560bf 100644
--- a/packages/frontend/app/utils/clone-learner-group.js
+++ b/packages/frontend/app/utils/clone-learner-group.js
@@ -1,5 +1,3 @@
-import { map } from 'rsvp';
-
 /**
  * Clones a group and all children returning all the groups in the order they were created
  * so the first group is the top most group in the tree. If they are saved in order then each parent
@@ -20,16 +18,20 @@ export default async function cloneLearnerGroup(store, group, cohort, withLearne
   }
   if (withLearners) {
     const users = await group.users;
-    await map(users, async (user) => {
-      await newGroup.addUserToGroupAndAllParents(user);
-    });
+    await Promise.all(
+      users.map(async (user) => {
+        await newGroup.addUserToGroupAndAllParents(user);
+      }),
+    );
   }
   const instructors = await group.instructors;
   newGroup.set('instructors', instructors);
   const children = await group.children;
-  const newChildren = await map(children, async (child) => {
-    return await cloneLearnerGroup(store, child, cohort, withLearners, newGroup);
-  });
+  const newChildren = await Promise.all(
+    children.map(async (child) => {
+      return await cloneLearnerGroup(store, child, cohort, withLearners, newGroup);
+    }),
+  );
   const flat = newChildren.reduce((flattened, children) => {
     return [...flattened, ...children];
   }, []);
diff --git a/packages/frontend/app/utils/sort-cohorts.js b/packages/frontend/app/utils/sort-cohorts.js
index 90b2849b36..d3b8805fda 100644
--- a/packages/frontend/app/utils/sort-cohorts.js
+++ b/packages/frontend/app/utils/sort-cohorts.js
@@ -1,18 +1,19 @@
-import { map } from 'rsvp';
 import { sortBy } from 'ilios-common/utils/array-helpers';
 
 export default async function sortCohorts(cohorts) {
-  const sortProxies = await map(cohorts, async (cohort) => {
-    const programYear = await cohort.programYear;
-    const program = await programYear.program;
-    const school = await program.school;
-    return {
-      cohort,
-      cohortTitle: cohort.title,
-      programTitle: program.title,
-      schoolTitle: school.title,
-    };
-  });
+  const sortProxies = await Promise.all(
+    cohorts.map(async (cohort) => {
+      const programYear = await cohort.programYear;
+      const program = await programYear.program;
+      const school = await program.school;
+      return {
+        cohort,
+        cohortTitle: cohort.title,
+        programTitle: program.title,
+        schoolTitle: school.title,
+      };
+    }),
+  );
   return sortBy(sortProxies, ['schoolTitle', 'programTitle', 'cohortTitle']).map(
     (sortedProxy) => sortedProxy.cohort,
   );
diff --git a/packages/ilios-common/addon/components/course/objective-list.gjs b/packages/ilios-common/addon/components/course/objective-list.gjs
index 8273e56c0c..152b3137d2 100644
--- a/packages/ilios-common/addon/components/course/objective-list.gjs
+++ b/packages/ilios-common/addon/components/course/objective-list.gjs
@@ -1,6 +1,5 @@
 import Component from '@glimmer/component';
 import { cached, tracked } from '@glimmer/tracking';
-import { map } from 'rsvp';
 import { service } from '@ember/service';
 import { TrackedAsyncData } from 'ember-async-data';
 import sortableByPosition from 'ilios-common/utils/sortable-by-position';
@@ -75,56 +74,60 @@ export default class CourseObjectiveListComponent extends Component {
   }
 
   async getCohortObjectives(cohorts, intl) {
-    return await map(cohorts, async (cohort) => {
-      const programYear = await cohort.programYear;
-      const program = await programYear.program;
-      const school = await program.school;
-      const allowMultipleCourseObjectiveParents = await school.getConfigValue(
-        'allowMultipleCourseObjectiveParents',
-      );
-      const objectives = await programYear.programYearObjectives;
-      const objectiveObjects = await map(objectives, async (objective) => {
-        let competencyId = 0;
-        let competencyTitle = intl.t('general.noAssociatedCompetency');
-        let competencyParent = null;
-        const competency = await objective.competency;
-        if (competency) {
-          competencyId = competency.id;
-          competencyTitle = competency.title;
-          competencyParent = await competency.parent;
-        }
+    return await Promise.all(
+      cohorts.map(async (cohort) => {
+        const programYear = await cohort.programYear;
+        const program = await programYear.program;
+        const school = await program.school;
+        const allowMultipleCourseObjectiveParents = await school.getConfigValue(
+          'allowMultipleCourseObjectiveParents',
+        );
+        const objectives = await programYear.programYearObjectives;
+        const objectiveObjects = await Promise.all(
+          objectives.map(async (objective) => {
+            let competencyId = 0;
+            let competencyTitle = intl.t('general.noAssociatedCompetency');
+            let competencyParent = null;
+            const competency = await objective.competency;
+            if (competency) {
+              competencyId = competency.id;
+              competencyTitle = competency.title;
+              competencyParent = await competency.parent;
+            }
+            return {
+              id: objective.id,
+              title: objective.title,
+              active: objective.active,
+              competencyId,
+              competencyTitle,
+              competencyParent,
+              cohortId: cohort.id,
+            };
+          }),
+        );
+        const competencies = objectiveObjects.reduce((set, obj) => {
+          let existing = findById(set, obj.competencyId);
+          if (!existing) {
+            existing = {
+              id: obj.competencyId,
+              title: obj.competencyTitle,
+              objectives: [],
+              parent: obj.competencyParent,
+            };
+            set.push(existing);
+          }
+          existing.objectives.push(obj);
+          return set;
+        }, []);
+
         return {
-          id: objective.id,
-          title: objective.title,
-          active: objective.active,
-          competencyId,
-          competencyTitle,
-          competencyParent,
-          cohortId: cohort.id,
+          title: `${program.title} ${cohort.title}`,
+          id: cohort.id,
+          allowMultipleParents: allowMultipleCourseObjectiveParents,
+          competencies,
         };
-      });
-      const competencies = objectiveObjects.reduce((set, obj) => {
-        let existing = findById(set, obj.competencyId);
-        if (!existing) {
-          existing = {
-            id: obj.competencyId,
-            title: obj.competencyTitle,
-            objectives: [],
-            parent: obj.competencyParent,
-          };
-          set.push(existing);
-        }
-        existing.objectives.push(obj);
-        return set;
-      }, []);
-
-      return {
-        title: `${program.title} ${cohort.title}`,
-        id: cohort.id,
-        allowMultipleParents: allowMultipleCourseObjectiveParents,
-        competencies,
-      };
-    });
+      }),
+    );
   }
   <template>
     <div class="course-objective-list" data-test-course-objective-list>
diff --git a/packages/ilios-common/addon/components/course/visualize-instructor-session-type-graph.gjs b/packages/ilios-common/addon/components/course/visualize-instructor-session-type-graph.gjs
index 30a5d1b5c9..49653b7df7 100644
--- a/packages/ilios-common/addon/components/course/visualize-instructor-session-type-graph.gjs
+++ b/packages/ilios-common/addon/components/course/visualize-instructor-session-type-graph.gjs
@@ -1,5 +1,5 @@
 import Component from '@glimmer/component';
-import { filter, map } from 'rsvp';
+import { filter } from 'rsvp';
 import { htmlSafe } from '@ember/template';
 import { task, timeout } from 'ember-concurrency';
 import { service } from '@ember/service';
@@ -90,22 +90,26 @@ export default class CourseVisualizeInstructorSessionTypeGraphComponent extends
       return mapBy(allInstructors, 'id').includes(user.id);
     });
 
-    const sessionsWithSessionType = await map(sessionsWithUser, async (session) => {
-      const sessionType = await session.sessionType;
-      return {
-        session,
-        sessionType,
-      };
-    });
+    const sessionsWithSessionType = await Promise.all(
+      sessionsWithUser.map(async (session) => {
+        const sessionType = await session.sessionType;
+        return {
+          session,
+          sessionType,
+        };
+      }),
+    );
 
-    const dataMap = await map(sessionsWithSessionType, async ({ session, sessionType }) => {
-      const minutes = await session.getTotalSumDurationByInstructor(this.args.user);
-      return {
-        session,
-        sessionType,
-        minutes,
-      };
-    });
+    const dataMap = await Promise.all(
+      sessionsWithSessionType.map(async ({ session, sessionType }) => {
+        const minutes = await session.getTotalSumDurationByInstructor(this.args.user);
+        return {
+          session,
+          sessionType,
+          minutes,
+        };
+      }),
+    );
 
     return dataMap
       .reduce((set, obj) => {
diff --git a/packages/ilios-common/addon/components/course/visualize-instructor-term-graph.gjs b/packages/ilios-common/addon/components/course/visualize-instructor-term-graph.gjs
index ca75504826..a26ddae06b 100644
--- a/packages/ilios-common/addon/components/course/visualize-instructor-term-graph.gjs
+++ b/packages/ilios-common/addon/components/course/visualize-instructor-term-graph.gjs
@@ -1,5 +1,5 @@
 import Component from '@glimmer/component';
-import { filter, map } from 'rsvp';
+import { filter } from 'rsvp';
 import { isEmpty } from '@ember/utils';
 import { htmlSafe } from '@ember/template';
 import { task, timeout } from 'ember-concurrency';
@@ -90,33 +90,39 @@ export default class CourseVisualizeInstructorTermGraphComponent extends Compone
       return mapBy(allInstructors, 'id').includes(user.id);
     });
 
-    const sessionsWithTerms = await map(sessionsWithUser, async (session) => {
-      const sessionTerms = await session.terms;
-      const terms = await map(sessionTerms, async (term) => {
-        const vocabulary = await term.vocabulary;
-        return {
-          term,
-          vocabulary,
-        };
-      });
-
-      return {
-        session,
-        terms,
-      };
-    });
+    const sessionsWithTerms = await Promise.all(
+      sessionsWithUser.map(async (session) => {
+        const sessionTerms = await session.terms;
+        const terms = await Promise.all(
+          sessionTerms.map(async (term) => {
+            const vocabulary = await term.vocabulary;
+            return {
+              term,
+              vocabulary,
+            };
+          }),
+        );
 
-    const dataMap = await map(sessionsWithTerms, async ({ session, terms }) => {
-      const minutes = await session.getTotalSumDurationByInstructor(this.args.user);
-      return terms.map(({ term, vocabulary }) => {
         return {
           session,
-          term,
-          vocabulary,
-          minutes,
+          terms,
         };
-      });
-    });
+      }),
+    );
+
+    const dataMap = await Promise.all(
+      sessionsWithTerms.map(async ({ session, terms }) => {
+        const minutes = await session.getTotalSumDurationByInstructor(this.args.user);
+        return terms.map(({ term, vocabulary }) => {
+          return {
+            session,
+            term,
+            vocabulary,
+            minutes,
+          };
+        });
+      }),
+    );
 
     return dataMap
       .reduce((flattened, arr) => {
diff --git a/packages/ilios-common/addon/components/course/visualize-instructor.gjs b/packages/ilios-common/addon/components/course/visualize-instructor.gjs
index 3613428be3..cdcef0ac52 100644
--- a/packages/ilios-common/addon/components/course/visualize-instructor.gjs
+++ b/packages/ilios-common/addon/components/course/visualize-instructor.gjs
@@ -1,6 +1,6 @@
 import Component from '@glimmer/component';
 import { service } from '@ember/service';
-import { map, filter } from 'rsvp';
+import { filter } from 'rsvp';
 import { TrackedAsyncData } from 'ember-async-data';
 import { cached } from '@glimmer/tracking';
 import { mapBy } from 'ilios-common/utils/array-helpers';
@@ -71,16 +71,18 @@ export default class CourseVisualizeInstructorComponent extends Component {
       return mapBy(instructors, 'id').includes(this.args.user.id);
     });
 
-    return map(sessionsWithUser, async (session) => {
-      const offeringMinutes = await session.getTotalSumOfferingsDurationByInstructor(
-        this.args.user,
-      );
-      const ilmMinutes = await session.getTotalSumIlmDurationByInstructor(this.args.user);
-      return {
-        offeringMinutes,
-        ilmMinutes,
-      };
-    });
+    return Promise.all(
+      sessionsWithUser.map(async (session) => {
+        const offeringMinutes = await session.getTotalSumOfferingsDurationByInstructor(
+          this.args.user,
+        );
+        const ilmMinutes = await session.getTotalSumIlmDurationByInstructor(this.args.user);
+        return {
+          offeringMinutes,
+          ilmMinutes,
+        };
+      }),
+    );
   }
   <template>
     <section
diff --git a/packages/ilios-common/addon/components/course/visualize-instructors-graph.gjs b/packages/ilios-common/addon/components/course/visualize-instructors-graph.gjs
index 25d3573435..1eea08e0db 100644
--- a/packages/ilios-common/addon/components/course/visualize-instructors-graph.gjs
+++ b/packages/ilios-common/addon/components/course/visualize-instructors-graph.gjs
@@ -2,7 +2,6 @@ import Component from '@glimmer/component';
 import { isEmpty } from '@ember/utils';
 import { htmlSafe } from '@ember/template';
 import { task, timeout } from 'ember-concurrency';
-import { map } from 'rsvp';
 import { service } from '@ember/service';
 import { cached, tracked } from '@glimmer/tracking';
 import { action } from '@ember/object';
@@ -101,20 +100,24 @@ export default class CourseVisualizeInstructorsGraphComponent extends Component
 
   async getData(course) {
     const sessions = await course.sessions;
-    const sessionsWithInstructors = await map(sessions, async (session) => {
-      const instructors = await session.getAllInstructors();
-      const instructorsWithInstructionalTime = await map(instructors, async (instructor) => {
-        const minutes = await session.getTotalSumOfferingsDurationByInstructor(instructor);
+    const sessionsWithInstructors = await Promise.all(
+      sessions.map(async (session) => {
+        const instructors = await session.getAllInstructors();
+        const instructorsWithInstructionalTime = await Promise.all(
+          instructors.map(async (instructor) => {
+            const minutes = await session.getTotalSumOfferingsDurationByInstructor(instructor);
+            return {
+              instructor,
+              minutes,
+            };
+          }),
+        );
         return {
-          instructor,
-          minutes,
+          session,
+          instructorsWithInstructionalTime,
         };
-      });
-      return {
-        session,
-        instructorsWithInstructionalTime,
-      };
-    });
+      }),
+    );
 
     return sessionsWithInstructors
       .reduce((set, { session, instructorsWithInstructionalTime }) => {
diff --git a/packages/ilios-common/addon/components/course/visualize-objectives-graph.gjs b/packages/ilios-common/addon/components/course/visualize-objectives-graph.gjs
index cc9888b618..22faa38e7b 100644
--- a/packages/ilios-common/addon/components/course/visualize-objectives-graph.gjs
+++ b/packages/ilios-common/addon/components/course/visualize-objectives-graph.gjs
@@ -3,7 +3,7 @@ import { cached, tracked } from '@glimmer/tracking';
 import { action } from '@ember/object';
 import { service } from '@ember/service';
 import { htmlSafe } from '@ember/template';
-import { filter, map } from 'rsvp';
+import { filter } from 'rsvp';
 import { task, timeout } from 'ember-concurrency';
 import { TrackedAsyncData } from 'ember-async-data';
 import striptags from 'striptags';
@@ -100,16 +100,17 @@ export default class CourseVisualizeObjectivesGraphComponent extends Component {
   }
 
   async getDataObjects(sessions) {
-    const sessionsWithMinutes = sessions.map(async (session) => {
-      const hours = await session.getTotalSumDuration();
-      return {
-        session,
-        minutes: Math.round(hours * 60),
-      };
-    });
-    const sessionCourseObjectiveMap = await map(
-      sessionsWithMinutes,
-      async ({ session, minutes }) => {
+    const sessionsWithMinutes = await Promise.all(
+      sessions.map(async (session) => {
+        const hours = await session.getTotalSumDuration();
+        return {
+          session,
+          minutes: Math.round(hours * 60),
+        };
+      }),
+    );
+    const sessionCourseObjectiveMap = await Promise.all(
+      sessionsWithMinutes.map(async ({ session, minutes }) => {
         const sessionObjectives = await session.sessionObjectives;
         const sessionObjectivesWithParents = await filter(
           sessionObjectives,
@@ -118,12 +119,11 @@ export default class CourseVisualizeObjectivesGraphComponent extends Component {
             return parents.length;
           },
         );
-        const courseSessionObjectives = await map(
-          sessionObjectivesWithParents,
-          async (sessionObjective) => {
+        const courseSessionObjectives = await Promise.all(
+          sessionObjectivesWithParents.map(async (sessionObjective) => {
             const parents = await sessionObjective.courseObjectives;
             return mapBy(parents, 'id');
-          },
+          }),
         );
         const flatObjectives = courseSessionObjectives.reduce((flattened, arr) => {
           return [...flattened, ...arr];
@@ -135,43 +135,50 @@ export default class CourseVisualizeObjectivesGraphComponent extends Component {
           objectives: flatObjectives,
           minutes,
         };
-      },
+      }),
     );
 
     // condensed objectives map
     const courseObjectives = await this.args.course.courseObjectives;
-    const mappedObjectives = await map(courseObjectives, async (courseObjective) => {
-      const programYearObjectives = await courseObjective.programYearObjectives;
-      const competencyTitles = (
-        await map(programYearObjectives, async (pyObjective) => {
-          const competency = await pyObjective.competency;
-          return competency ? competency.title : null;
-        })
-      )
-        .filter((title) => !!title)
-        .sort();
-      const minutes = sessionCourseObjectiveMap.map((obj) => {
-        if (obj.objectives.includes(courseObjective.id)) {
-          return obj.minutes;
-        } else {
-          return 0;
-        }
-      });
-      const sessionObjectives = sessionCourseObjectiveMap.filter((obj) =>
-        obj.objectives.includes(courseObjective.id),
-      );
-      const meta = {
-        competencies: uniqueValues(competencyTitles).join(', '),
-        courseObjective,
-        sessionObjectives,
-      };
-      const data = minutes.reduce((accumulator, current) => accumulator + parseInt(current, 10), 0);
+    const mappedObjectives = await Promise.all(
+      courseObjectives.map(async (courseObjective) => {
+        const programYearObjectives = await courseObjective.programYearObjectives;
+        const competencyTitles = (
+          await Promise.all(
+            programYearObjectives.map(async (pyObjective) => {
+              const competency = await pyObjective.competency;
+              return competency ? competency.title : null;
+            }),
+          )
+        )
+          .filter((title) => !!title)
+          .sort();
+        const minutes = sessionCourseObjectiveMap.map((obj) => {
+          if (obj.objectives.includes(courseObjective.id)) {
+            return obj.minutes;
+          } else {
+            return 0;
+          }
+        });
+        const sessionObjectives = sessionCourseObjectiveMap.filter((obj) =>
+          obj.objectives.includes(courseObjective.id),
+        );
+        const meta = {
+          competencies: uniqueValues(competencyTitles).join(', '),
+          courseObjective,
+          sessionObjectives,
+        };
+        const data = minutes.reduce(
+          (accumulator, current) => accumulator + parseInt(current, 10),
+          0,
+        );
 
-      return {
-        data,
-        meta,
-      };
-    });
+        return {
+          data,
+          meta,
+        };
+      }),
+    );
 
     const totalMinutes = mapBy(mappedObjectives, 'data').reduce(
       (total, minutes) => total + minutes,
diff --git a/packages/ilios-common/addon/components/course/visualize-session-type-graph.gjs b/packages/ilios-common/addon/components/course/visualize-session-type-graph.gjs
index e83580753d..b460499e7a 100644
--- a/packages/ilios-common/addon/components/course/visualize-session-type-graph.gjs
+++ b/packages/ilios-common/addon/components/course/visualize-session-type-graph.gjs
@@ -1,5 +1,4 @@
 import Component from '@glimmer/component';
-import { map } from 'rsvp';
 import { isEmpty } from '@ember/utils';
 import { htmlSafe } from '@ember/template';
 import { task, timeout } from 'ember-concurrency';
@@ -106,26 +105,32 @@ export default class CourseVisualizeSessionTypeGraphComponent extends Component
       sessionTypeSessions.includes(session),
     );
 
-    const sessionsWithMinutes = map(courseSessionsWithSessionType, async (session) => {
-      const hours = await session.getTotalSumDuration();
-      return {
-        session,
-        minutes: Math.round(hours * 60),
-      };
-    });
-
-    const termData = await map(sessionsWithMinutes, async ({ session, minutes }) => {
-      const terms = await session.terms;
-      return map(terms, async (term) => {
-        const vocabulary = await term.vocabulary;
+    const sessionsWithMinutes = await Promise.all(
+      courseSessionsWithSessionType.map(async (session) => {
+        const hours = await session.getTotalSumDuration();
         return {
           session,
-          term,
-          vocabulary,
-          minutes,
+          minutes: Math.round(hours * 60),
         };
-      });
-    });
+      }),
+    );
+
+    const termData = await Promise.all(
+      sessionsWithMinutes.map(async ({ session, minutes }) => {
+        const terms = await session.terms;
+        return Promise.all(
+          terms.map(async (term) => {
+            const vocabulary = await term.vocabulary;
+            return {
+              session,
+              term,
+              vocabulary,
+              minutes,
+            };
+          }),
+        );
+      }),
+    );
 
     return termData
       .reduce((flattened, arr) => {
diff --git a/packages/ilios-common/addon/components/course/visualize-session-types-graph.gjs b/packages/ilios-common/addon/components/course/visualize-session-types-graph.gjs
index 32d089fbdb..7471e79728 100644
--- a/packages/ilios-common/addon/components/course/visualize-session-types-graph.gjs
+++ b/packages/ilios-common/addon/components/course/visualize-session-types-graph.gjs
@@ -4,7 +4,6 @@ import { task, timeout } from 'ember-concurrency';
 import { service } from '@ember/service';
 import { cached, tracked } from '@glimmer/tracking';
 import { action } from '@ember/object';
-import { map } from 'rsvp';
 import { TrackedAsyncData } from 'ember-async-data';
 import PapaParse from 'papaparse';
 import { cleanQuery } from 'ilios-common/utils/query-utils';
@@ -105,16 +104,18 @@ export default class CourseVisualizeSessionTypesGraphComponent extends Component
       return [];
     }
 
-    const dataMap = await map(sessions, async (session) => {
-      const hours = await session.getTotalSumDuration();
-      const minutes = Math.round(hours * 60);
-      const sessionType = await session.sessionType;
-      return {
-        session,
-        sessionType,
-        minutes,
-      };
-    });
+    const dataMap = await Promise.all(
+      sessions.map(async (session) => {
+        const hours = await session.getTotalSumDuration();
+        const minutes = Math.round(hours * 60);
+        const sessionType = await session.sessionType;
+        return {
+          session,
+          sessionType,
+          minutes,
+        };
+      }),
+    );
 
     return dataMap
       .reduce((set, { sessionType, session, minutes }) => {
diff --git a/packages/ilios-common/addon/components/course/visualize-term-graph.gjs b/packages/ilios-common/addon/components/course/visualize-term-graph.gjs
index c19326a76c..b36a6ee272 100644
--- a/packages/ilios-common/addon/components/course/visualize-term-graph.gjs
+++ b/packages/ilios-common/addon/components/course/visualize-term-graph.gjs
@@ -1,5 +1,4 @@
 import Component from '@glimmer/component';
-import { map } from 'rsvp';
 import { htmlSafe } from '@ember/template';
 import { task, timeout } from 'ember-concurrency';
 import { service } from '@ember/service';
@@ -84,15 +83,17 @@ export default class CourseVisualizeTermGraphComponent extends Component {
     const sessionIds = term.hasMany('sessions').ids();
     const filteredSessions = sessions.filter((session) => sessionIds.includes(session.id));
     const sessionTypes = await Promise.all(filteredSessions.map((s) => s.sessionType));
-    const sessionTypeData = await map(filteredSessions, async (session) => {
-      const hours = await session.getTotalSumDuration();
-      const sessionType = findById(sessionTypes, session.belongsTo('sessionType').id());
-      return {
-        session,
-        sessionType,
-        minutes: Math.round(hours * 60),
-      };
-    });
+    const sessionTypeData = await Promise.all(
+      filteredSessions.map(async (session) => {
+        const hours = await session.getTotalSumDuration();
+        const sessionType = findById(sessionTypes, session.belongsTo('sessionType').id());
+        return {
+          session,
+          sessionType,
+          minutes: Math.round(hours * 60),
+        };
+      }),
+    );
 
     return sessionTypeData
       .reduce((set, { sessionType, session, minutes }) => {
diff --git a/packages/ilios-common/addon/components/course/visualize-vocabularies-graph.gjs b/packages/ilios-common/addon/components/course/visualize-vocabularies-graph.gjs
index 87f5b695b1..51ca5080eb 100644
--- a/packages/ilios-common/addon/components/course/visualize-vocabularies-graph.gjs
+++ b/packages/ilios-common/addon/components/course/visualize-vocabularies-graph.gjs
@@ -1,5 +1,4 @@
 import Component from '@glimmer/component';
-import { map } from 'rsvp';
 import { htmlSafe } from '@ember/template';
 import { task, timeout } from 'ember-concurrency';
 import { service } from '@ember/service';
@@ -86,17 +85,18 @@ export default class CourseVisualizeVocabulariesGraphComponent extends Component
       return [];
     }
 
-    const sessionsWithMinutes = await map(sessions, async (session) => {
-      const hours = await session.getTotalSumDuration();
-      return {
-        session,
-        minutes: Math.round(hours * 60),
-      };
-    });
+    const sessionsWithMinutes = await Promise.all(
+      sessions.map(async (session) => {
+        const hours = await session.getTotalSumDuration();
+        return {
+          session,
+          minutes: Math.round(hours * 60),
+        };
+      }),
+    );
 
-    const sessionWithMinutesAndVocabs = await map(
-      sessionsWithMinutes,
-      async ({ session, minutes }) => {
+    const sessionWithMinutesAndVocabs = await Promise.all(
+      sessionsWithMinutes.map(async ({ session, minutes }) => {
         const terms = await session.terms;
         const vocabularies = await Promise.all(mapBy(terms, 'vocabulary'));
         return {
@@ -104,7 +104,7 @@ export default class CourseVisualizeVocabulariesGraphComponent extends Component
           vocabularies: uniqueById(vocabularies),
           minutes,
         };
-      },
+      }),
     );
 
     return sessionWithMinutesAndVocabs
diff --git a/packages/ilios-common/addon/components/course/visualize-vocabulary-graph.gjs b/packages/ilios-common/addon/components/course/visualize-vocabulary-graph.gjs
index 22981bbe34..995e5b6923 100644
--- a/packages/ilios-common/addon/components/course/visualize-vocabulary-graph.gjs
+++ b/packages/ilios-common/addon/components/course/visualize-vocabulary-graph.gjs
@@ -1,5 +1,5 @@
 import Component from '@glimmer/component';
-import { filter, map } from 'rsvp';
+import { filter } from 'rsvp';
 import { htmlSafe } from '@ember/template';
 import { task, timeout } from 'ember-concurrency';
 import { service } from '@ember/service';
@@ -85,16 +85,17 @@ export default class CourseVisualizeVocabularyGraphComponent extends Component {
     if (!sessions.length) {
       return [];
     }
-    const sessionsWithMinutes = await map(sessions, async (session) => {
-      const hours = await session.getTotalSumDuration();
-      return {
-        session,
-        minutes: Math.round(hours * 60),
-      };
-    });
-    const termsWithSessionAndMinutes = await map(
-      sessionsWithMinutes,
-      async ({ session, minutes }) => {
+    const sessionsWithMinutes = await Promise.all(
+      sessions.map(async (session) => {
+        const hours = await session.getTotalSumDuration();
+        return {
+          session,
+          minutes: Math.round(hours * 60),
+        };
+      }),
+    );
+    const termsWithSessionAndMinutes = await Promise.all(
+      sessionsWithMinutes.map(async ({ session, minutes }) => {
         const sessionTerms = await session.terms;
         const sessionTermsInThisVocabulary = await filter(sessionTerms, async (term) => {
           const termVocab = await term.vocabulary;
@@ -107,7 +108,7 @@ export default class CourseVisualizeVocabularyGraphComponent extends Component {
             minutes,
           };
         });
-      },
+      }),
     );
 
     return termsWithSessionAndMinutes
diff --git a/packages/ilios-common/addon/components/dashboard/calendar.gjs b/packages/ilios-common/addon/components/dashboard/calendar.gjs
index 3fd4f4fa70..67f85a792a 100644
--- a/packages/ilios-common/addon/components/dashboard/calendar.gjs
+++ b/packages/ilios-common/addon/components/dashboard/calendar.gjs
@@ -3,7 +3,6 @@ import { service } from '@ember/service';
 import { cached, tracked } from '@glimmer/tracking';
 import { action } from '@ember/object';
 import { DateTime } from 'luxon';
-import { map } from 'rsvp';
 import { mapBy, sortBy } from 'ilios-common/utils/array-helpers';
 import { TrackedAsyncData } from 'ember-async-data';
 import ToggleButtons from 'ilios-common/components/toggle-buttons';
@@ -139,24 +138,26 @@ export default class DashboardCalendarComponent extends Component {
       return;
     }
     const cohorts = await this.getSchoolCohorts(school);
-    const cohortProxies = await map(cohorts, async (cohort) => {
-      let displayTitle = cohort.title;
-      const programYear = await cohort.programYear;
-      const classOfYear = await programYear.getClassOfYear();
-      if (!displayTitle) {
-        const intl = this.intl;
-        displayTitle = intl.t('general.classOf', { year: classOfYear });
-      }
-      const program = await programYear.program;
-
-      return {
-        id: cohort.id,
-        programTitle: program.title,
-        cohort,
-        displayTitle,
-        classOfYear,
-      };
-    });
+    const cohortProxies = await Promise.all(
+      cohorts.map(async (cohort) => {
+        let displayTitle = cohort.title;
+        const programYear = await cohort.programYear;
+        const classOfYear = await programYear.getClassOfYear();
+        if (!displayTitle) {
+          const intl = this.intl;
+          displayTitle = intl.t('general.classOf', { year: classOfYear });
+        }
+        const program = await programYear.program;
+
+        return {
+          id: cohort.id,
+          programTitle: program.title,
+          cohort,
+          displayTitle,
+          classOfYear,
+        };
+      }),
+    );
 
     return sortBy(cohortProxies, 'displayTitle');
   }
@@ -164,10 +165,12 @@ export default class DashboardCalendarComponent extends Component {
   async getSchoolCohorts(school) {
     await this.dataLoader.loadSchoolForCalendar(school.id);
     const programs = await school.programs;
-    const programYears = await map(programs, async (program) => {
-      const programYears = await program.programYears;
-      return programYears;
-    });
+    const programYears = await Promise.all(
+      programs.map(async (program) => {
+        const programYears = await program.programYears;
+        return programYears;
+      }),
+    );
     const cohorts = await Promise.all(mapBy(programYears.flat(), 'cohort'));
     return cohorts.filter(Boolean);
   }
diff --git a/packages/ilios-common/addon/components/detail-cohort-list.gjs b/packages/ilios-common/addon/components/detail-cohort-list.gjs
index 3a095bad1a..cfa38dcd84 100644
--- a/packages/ilios-common/addon/components/detail-cohort-list.gjs
+++ b/packages/ilios-common/addon/components/detail-cohort-list.gjs
@@ -1,7 +1,6 @@
 import Component from '@glimmer/component';
 import { service } from '@ember/service';
 import { cached } from '@glimmer/tracking';
-import { map } from 'rsvp';
 import { sortBy } from 'ilios-common/utils/array-helpers';
 import { TrackedAsyncData } from 'ember-async-data';
 import t from 'ember-intl/helpers/t';
@@ -26,24 +25,26 @@ export default class DetailCohortListComponent extends Component {
   }
 
   async getCohortProxies(cohorts) {
-    return await map(cohorts, async (cohort) => {
-      const programYear = await cohort.programYear;
-      const program = await programYear.program;
-      const school = await program.school;
-      const schoolTitle = school.title;
-      let displayTitle = cohort.title;
-      if (!displayTitle) {
+    return await Promise.all(
+      cohorts.map(async (cohort) => {
         const programYear = await cohort.programYear;
-        const year = await programYear.getClassOfYear();
-        displayTitle = this.intl.t('general.classOf', { year });
-      }
+        const program = await programYear.program;
+        const school = await program.school;
+        const schoolTitle = school.title;
+        let displayTitle = cohort.title;
+        if (!displayTitle) {
+          const programYear = await cohort.programYear;
+          const year = await programYear.getClassOfYear();
+          displayTitle = this.intl.t('general.classOf', { year });
+        }
 
-      return {
-        cohort,
-        schoolTitle,
-        displayTitle,
-      };
-    });
+        return {
+          cohort,
+          schoolTitle,
+          displayTitle,
+        };
+      }),
+    );
   }
   <template>
     <div class="detail-cohort-list" data-test-detail-cohort-list>
diff --git a/packages/ilios-common/addon/components/detail-cohort-manager.gjs b/packages/ilios-common/addon/components/detail-cohort-manager.gjs
index ef352a35cb..cf83577d80 100644
--- a/packages/ilios-common/addon/components/detail-cohort-manager.gjs
+++ b/packages/ilios-common/addon/components/detail-cohort-manager.gjs
@@ -1,7 +1,7 @@
 import Component from '@glimmer/component';
 import { service } from '@ember/service';
 import { cached, tracked } from '@glimmer/tracking';
-import { map, filter } from 'rsvp';
+import { filter } from 'rsvp';
 import { mapBy } from 'ilios-common/utils/array-helpers';
 import { TrackedAsyncData } from 'ember-async-data';
 import sortBy from 'ilios-common/helpers/sort-by';
@@ -84,13 +84,15 @@ export default class DetailCohortManagerComponent extends Component {
   async loadCohorts(course) {
     const school = await course.school;
     const allCohorts = await this.store.findAll('cohort');
-    const cohortProxies = await map(allCohorts, async (cohort) => {
-      const programYear = await cohort.programYear;
-      const program = await programYear.program;
-      const school = await program.school;
-
-      return { school, program, programYear, cohort };
-    });
+    const cohortProxies = await Promise.all(
+      allCohorts.map(async (cohort) => {
+        const programYear = await cohort.programYear;
+        const program = await programYear.program;
+        const school = await program.school;
+
+        return { school, program, programYear, cohort };
+      }),
+    );
 
     return filter(cohortProxies, async (obj) => {
       if (obj.school === school) {
diff --git a/packages/ilios-common/addon/components/detail-cohorts.gjs b/packages/ilios-common/addon/components/detail-cohorts.gjs
index 57a37fbf31..f6874bb98b 100644
--- a/packages/ilios-common/addon/components/detail-cohorts.gjs
+++ b/packages/ilios-common/addon/components/detail-cohorts.gjs
@@ -2,7 +2,7 @@ import Component from '@glimmer/component';
 import { cached, tracked } from '@glimmer/tracking';
 import { action } from '@ember/object';
 import { task } from 'ember-concurrency';
-import { filter, map } from 'rsvp';
+import { filter } from 'rsvp';
 import { TrackedAsyncData } from 'ember-async-data';
 import t from 'ember-intl/helpers/t';
 import { on } from '@ember/modifier';
@@ -42,13 +42,14 @@ export default class DetailCohortsComponent extends Component {
       const courseObjectives = await course.courseObjectives;
 
       // get a hold of all program years linked to the cohorts that are about to be unlinked from the given course.
-      const programYearsToRemove = await map(removedCohorts, async (cohort) => cohort.programYear);
+      const programYearsToRemove = await Promise.all(
+        removedCohorts.map(async (cohort) => cohort.programYear),
+      );
 
       // get all the program year objectives linked to the given program years.
       const programYearObjectivesToUnlink = (
-        await map(
-          programYearsToRemove,
-          async (programYear) => await programYear.programYearObjectives,
+        await Promise.all(
+          programYearsToRemove.map(async (programYear) => await programYear.programYearObjectives),
         )
       ).flat();
 
@@ -63,13 +64,15 @@ export default class DetailCohortsComponent extends Component {
       });
 
       // now, break linkage between the given course objectives and the given program year objectives.
-      await map(courseObjectivesToUnlink, async (courseObjective) => {
-        // @see https://guides.emberjs.com/release/models/relationships/#toc_removing-relationships
-        const programYearObjectives = await courseObjective.programYearObjectives;
-        courseObjective.programYearObjectives = programYearObjectives.filter(
-          (programYearObjective) => !programYearObjectivesToUnlink.includes(programYearObjective),
-        );
-      });
+      await Promise.all(
+        courseObjectivesToUnlink.map(async (courseObjective) => {
+          // @see https://guides.emberjs.com/release/models/relationships/#toc_removing-relationships
+          const programYearObjectives = await courseObjective.programYearObjectives;
+          courseObjective.programYearObjectives = programYearObjectives.filter(
+            (programYearObjective) => !programYearObjectivesToUnlink.includes(programYearObjective),
+          );
+        }),
+      );
 
       // save all given course objectives that need updating.
       await Promise.all(courseObjectivesToUnlink.map((courseObjective) => courseObjective.save()));
diff --git a/packages/ilios-common/addon/components/detail-learnergroups-list.gjs b/packages/ilios-common/addon/components/detail-learnergroups-list.gjs
index f95b54c73c..ade6225c8b 100644
--- a/packages/ilios-common/addon/components/detail-learnergroups-list.gjs
+++ b/packages/ilios-common/addon/components/detail-learnergroups-list.gjs
@@ -1,6 +1,6 @@
 import Component from '@glimmer/component';
 import { cached } from '@glimmer/tracking';
-import { filter, map } from 'rsvp';
+import { filter } from 'rsvp';
 import { TrackedAsyncData } from 'ember-async-data';
 import { mapBy, uniqueValues } from 'ilios-common/utils/array-helpers';
 import DetailLearnergroupsListItem from 'ilios-common/components/detail-learnergroups-list-item';
@@ -29,32 +29,36 @@ export default class DetailLearnerGroupsListComponent extends Component {
       return [];
     }
     const cohorts = uniqueValues(
-      await map(this.args.learnerGroups, async (learnerGroup) => {
-        return learnerGroup.cohort;
-      }),
-    );
-    return map(cohorts, async (cohort) => {
-      const groups = await filter(this.args.learnerGroups, async (group) => {
-        const groupCohort = await group.cohort;
-        return groupCohort === cohort;
-      });
-      const proxies = await Promise.all(
-        groups.map(async (group) => {
-          const title = await group.getTitleWithParentTitles();
-          return { group, title };
+      await Promise.all(
+        this.args.learnerGroups.map(async (learnerGroup) => {
+          return learnerGroup.cohort;
         }),
-      );
-      const sortedProxies = proxies.sort((a, b) => {
-        const titleA = a.title.toLowerCase();
-        const titleB = b.title.toLowerCase();
-        return titleA > titleB ? 1 : titleA < titleB ? -1 : 0;
-      });
+      ),
+    );
+    return Promise.all(
+      cohorts.map(async (cohort) => {
+        const groups = await filter(this.args.learnerGroups, async (group) => {
+          const groupCohort = await group.cohort;
+          return groupCohort === cohort;
+        });
+        const proxies = await Promise.all(
+          groups.map(async (group) => {
+            const title = await group.getTitleWithParentTitles();
+            return { group, title };
+          }),
+        );
+        const sortedProxies = proxies.sort((a, b) => {
+          const titleA = a.title.toLowerCase();
+          const titleB = b.title.toLowerCase();
+          return titleA > titleB ? 1 : titleA < titleB ? -1 : 0;
+        });
 
-      return {
-        cohort,
-        groups: mapBy(sortedProxies, 'group'),
-      };
-    });
+        return {
+          cohort,
+          groups: mapBy(sortedProxies, 'group'),
+        };
+      }),
+    );
   }
   <template>
     <div class="detail-learnergroups-list" data-test-detail-learnergroups-list>
diff --git a/packages/ilios-common/addon/components/offering-calendar.gjs b/packages/ilios-common/addon/components/offering-calendar.gjs
index 8d1ba0399d..eb850b0b2d 100644
--- a/packages/ilios-common/addon/components/offering-calendar.gjs
+++ b/packages/ilios-common/addon/components/offering-calendar.gjs
@@ -1,6 +1,5 @@
 import Component from '@glimmer/component';
 import { cached, tracked } from '@glimmer/tracking';
-import { map } from 'rsvp';
 import { DateTime } from 'luxon';
 import { TrackedAsyncData } from 'ember-async-data';
 import t from 'ember-intl/helpers/t';
@@ -41,13 +40,51 @@ export default class OfferingCalendarComponent extends Component {
     if (!learnerGroups) {
       this.learnerGroupEvents = [];
     } else {
-      const data = await map(learnerGroups, async (learnerGroup) => {
-        const offerings = await learnerGroup.offerings;
-        return await map(offerings, async (offering) => {
-          const session = await offering.session;
-          const sessionType = await session.sessionType;
-          const course = await session.course;
-          const school = await course.school;
+      const data = await Promise.all(
+        learnerGroups.map(async (learnerGroup) => {
+          const offerings = await learnerGroup.offerings;
+          return await Promise.all(
+            offerings.map(async (offering) => {
+              const session = await offering.session;
+              const sessionType = await session.sessionType;
+              const course = await session.course;
+              const school = await course.school;
+              return new Event(
+                {
+                  startDate: DateTime.fromJSDate(offering.startDate).toISO(),
+                  endDate: DateTime.fromJSDate(offering.endDate).toISO(),
+                  courseTitle: course.title,
+                  school: school.id,
+                  name: session.title,
+                  offering: offering.id,
+                  location: offering.location,
+                  color: sessionType.calendarColor,
+                  postrequisites: [],
+                  prerequisites: [],
+                },
+                false,
+                true,
+              );
+            }),
+          );
+        }),
+      );
+
+      this.learnerGroupEvents = data.reduce((flattened, obj) => {
+        return [...flattened, ...obj];
+      }, []);
+    }
+
+    if (!session) {
+      this.sessionEvents = [];
+      this.currentEvent = null;
+    } else {
+      const offerings = await session.offerings;
+      const sessionType = await session.sessionType;
+      const course = await session.course;
+      const school = await course.school;
+      this.sessionEvents = await Promise.all(
+        offerings.map(async (offering) => {
           return new Event(
             {
               startDate: DateTime.fromJSDate(offering.startDate).toISO(),
@@ -64,40 +101,8 @@ export default class OfferingCalendarComponent extends Component {
             false,
             true,
           );
-        });
-      });
-
-      this.learnerGroupEvents = data.reduce((flattened, obj) => {
-        return [...flattened, ...obj];
-      }, []);
-    }
-
-    if (!session) {
-      this.sessionEvents = [];
-      this.currentEvent = null;
-    } else {
-      const offerings = await session.offerings;
-      const sessionType = await session.sessionType;
-      const course = await session.course;
-      const school = await course.school;
-      this.sessionEvents = await map(offerings, async (offering) => {
-        return new Event(
-          {
-            startDate: DateTime.fromJSDate(offering.startDate).toISO(),
-            endDate: DateTime.fromJSDate(offering.endDate).toISO(),
-            courseTitle: course.title,
-            school: school.id,
-            name: session.title,
-            offering: offering.id,
-            location: offering.location,
-            color: sessionType.calendarColor,
-            postrequisites: [],
-            prerequisites: [],
-          },
-          false,
-          true,
-        );
-      });
+        }),
+      );
 
       this.currentEvent = new Event(
         {
diff --git a/packages/ilios-common/addon/components/offering-form.gjs b/packages/ilios-common/addon/components/offering-form.gjs
index f38b543960..0d22e160ce 100644
--- a/packages/ilios-common/addon/components/offering-form.gjs
+++ b/packages/ilios-common/addon/components/offering-form.gjs
@@ -3,7 +3,7 @@ import { cached, tracked } from '@glimmer/tracking';
 import { action } from '@ember/object';
 import { service } from '@ember/service';
 import { isEmpty, isPresent } from '@ember/utils';
-import { hash, map } from 'rsvp';
+import { hash } from 'rsvp';
 import { DateTime } from 'luxon';
 import { mixed, number, string } from 'yup';
 import { task, timeout } from 'ember-concurrency';
@@ -241,14 +241,18 @@ export default class OfferingFormComponent extends Component {
     if (isEmpty(cohorts)) {
       associatedSchools = [];
     } else {
-      const cohortSchools = await map(cohorts, async (cohort) => {
-        const programYear = await cohort.programYear;
-        const program = await programYear.program;
-        return program.school;
-      });
+      const cohortSchools = await Promise.all(
+        cohorts.map(async (cohort) => {
+          const programYear = await cohort.programYear;
+          const program = await programYear.program;
+          return program.school;
+        }),
+      );
       associatedSchools = uniqueValues(cohortSchools);
     }
-    const allInstructorGroups = await map(associatedSchools, (school) => school.instructorGroups);
+    const allInstructorGroups = await Promise.all(
+      associatedSchools.map((school) => school.instructorGroups),
+    );
     return allInstructorGroups.reduce((flattened, arr) => {
       return [...flattened, ...arr];
     }, []);
@@ -457,19 +461,9 @@ export default class OfferingFormComponent extends Component {
     let parts;
     while (offerings.length > 0) {
       parts = offerings.splice(0, 5);
-      await map(
-        parts,
-        ({
-          startDate,
-          endDate,
-          room,
-          url,
-          learnerGroups,
-          learners,
-          instructorGroups,
-          instructors,
-        }) => {
-          return this.args.save(
+      await Promise.all(
+        parts.map(
+          ({
             startDate,
             endDate,
             room,
@@ -478,8 +472,19 @@ export default class OfferingFormComponent extends Component {
             learners,
             instructorGroups,
             instructors,
-          );
-        },
+          }) => {
+            return this.args.save(
+              startDate,
+              endDate,
+              room,
+              url,
+              learnerGroups,
+              learners,
+              instructorGroups,
+              instructors,
+            );
+          },
+        ),
       );
       savedOfferings = savedOfferings + parts.length;
       this.saveProgressPercent = Math.floor((savedOfferings / totalOfferings) * 100);
diff --git a/packages/ilios-common/addon/components/session-offerings-time-block-offerings.gjs b/packages/ilios-common/addon/components/session-offerings-time-block-offerings.gjs
index 61d6aac8e5..b01808a015 100644
--- a/packages/ilios-common/addon/components/session-offerings-time-block-offerings.gjs
+++ b/packages/ilios-common/addon/components/session-offerings-time-block-offerings.gjs
@@ -1,6 +1,5 @@
 import Component from '@glimmer/component';
 import { cached } from '@glimmer/tracking';
-import { map } from 'rsvp';
 import { TrackedAsyncData } from 'ember-async-data';
 import { sortBy } from 'ilios-common/utils/array-helpers';
 import OfferingManager from 'ilios-common/components/offering-manager';
@@ -16,13 +15,15 @@ export default class SessionOfferingsTimeBlockOfferingsComponent extends Compone
   }
 
   async sortOfferings(offeringTimeBlock) {
-    const sortProxies = await map(offeringTimeBlock.offerings, async (offering) => {
-      const learnerGroups = await offering.learnerGroups;
-      return {
-        title: learnerGroups.length ? learnerGroups.slice()[0].title : null,
-        offering,
-      };
-    });
+    const sortProxies = await Promise.all(
+      offeringTimeBlock.offerings.map(async (offering) => {
+        const learnerGroups = await offering.learnerGroups;
+        return {
+          title: learnerGroups.length ? learnerGroups.slice()[0].title : null,
+          offering,
+        };
+      }),
+    );
     return sortBy(sortProxies, 'title').map((proxy) => proxy.offering);
   }
   <template>
diff --git a/packages/ilios-common/addon/components/sessions-grid-offering-table-offerings.gjs b/packages/ilios-common/addon/components/sessions-grid-offering-table-offerings.gjs
index c76d9ce4c8..417affa281 100644
--- a/packages/ilios-common/addon/components/sessions-grid-offering-table-offerings.gjs
+++ b/packages/ilios-common/addon/components/sessions-grid-offering-table-offerings.gjs
@@ -1,6 +1,5 @@
 import Component from '@glimmer/component';
 import { cached } from '@glimmer/tracking';
-import { map } from 'rsvp';
 import { TrackedAsyncData } from 'ember-async-data';
 import { sortBy } from 'ilios-common/utils/array-helpers';
 import SessionsGridOffering from 'ilios-common/components/sessions-grid-offering';
@@ -19,13 +18,15 @@ export default class SessionsGridOfferingTableOfferingsComponent extends Compone
   }
 
   async sortOfferings(offeringTimeBlock) {
-    const sortProxies = await map(offeringTimeBlock.offerings, async (offering) => {
-      const learnerGroups = await offering.learnerGroups;
-      return {
-        title: learnerGroups.length ? learnerGroups.slice()[0].title : null,
-        offering,
-      };
-    });
+    const sortProxies = await Promise.all(
+      offeringTimeBlock.offerings.map(async (offering) => {
+        const learnerGroups = await offering.learnerGroups;
+        return {
+          title: learnerGroups.length ? learnerGroups.slice()[0].title : null,
+          offering,
+        };
+      }),
+    );
     return sortBy(sortProxies, 'title').map((proxy) => proxy.offering);
   }
   <template>
diff --git a/packages/ilios-common/addon/components/sessions-grid.gjs b/packages/ilios-common/addon/components/sessions-grid.gjs
index 3878c49dfb..b7cb194040 100644
--- a/packages/ilios-common/addon/components/sessions-grid.gjs
+++ b/packages/ilios-common/addon/components/sessions-grid.gjs
@@ -6,7 +6,7 @@ import { service } from '@ember/service';
 import { next } from '@ember/runloop';
 import { task } from 'ember-concurrency';
 import { DateTime } from 'luxon';
-import { filter, map } from 'rsvp';
+import { filter } from 'rsvp';
 import escapeRegExp from 'ilios-common/utils/escape-reg-exp';
 import { sortBy } from 'ilios-common/utils/array-helpers';
 import { TrackedAsyncData } from 'ember-async-data';
@@ -90,41 +90,49 @@ export default class SessionsGridComponent extends Component {
   }
 
   async sortBySessionTypeTitle(sessions, sortInfo) {
-    const sortProxies = await map(sessions, async (session) => {
-      const sessionType = await session.sessionType;
-      const sessionTypeTitle = sessionType?.title;
-      return {
-        session,
-        title: sessionTypeTitle,
-      };
-    });
+    const sortProxies = await Promise.all(
+      sessions.map(async (session) => {
+        const sessionType = await session.sessionType;
+        const sessionTypeTitle = sessionType?.title;
+        return {
+          session,
+          title: sessionTypeTitle,
+        };
+      }),
+    );
     const sortedSessions = sortBy(sortProxies, 'title').map((proxy) => proxy.session);
     return sortInfo.descending ? sortedSessions.reverse() : sortedSessions;
   }
 
   async sortByLearnerGroupCount(sessions, sortInfo) {
-    const sortProxies = await map(sessions, async (session) => {
-      const offerings = await session.offerings;
-      const learnerGroups = await map(offerings, async (offering) => {
-        return await offering.learnerGroups;
-      });
-      return {
-        session,
-        learnerGroupCount: learnerGroups.flat().length,
-      };
-    });
+    const sortProxies = await Promise.all(
+      sessions.map(async (session) => {
+        const offerings = await session.offerings;
+        const learnerGroups = await Promise.all(
+          offerings.map(async (offering) => {
+            return await offering.learnerGroups;
+          }),
+        );
+        return {
+          session,
+          learnerGroupCount: learnerGroups.flat().length,
+        };
+      }),
+    );
     const sortedSessions = sortBy(sortProxies, 'learnerGroupCount').map((proxy) => proxy.session);
     return sortInfo.descending ? sortedSessions.reverse() : sortedSessions;
   }
 
   async sortByFirstOfferingDate(sessions, sortInfo) {
-    const sortProxies = await map(sessions, async (session) => {
-      const firstOfferingDate = await this.getFirstOfferingDate(session);
-      return {
-        session,
-        firstOfferingDate,
-      };
-    });
+    const sortProxies = await Promise.all(
+      sessions.map(async (session) => {
+        const firstOfferingDate = await this.getFirstOfferingDate(session);
+        return {
+          session,
+          firstOfferingDate,
+        };
+      }),
+    );
     const sortedSessions = sortBy(sortProxies, 'firstOfferingDate').map((proxy) => proxy.session);
     return sortInfo.descending ? sortedSessions.reverse() : sortedSessions;
   }
diff --git a/packages/ilios-common/addon/models/course.js b/packages/ilios-common/addon/models/course.js
index c0f017c7cb..a61cce88aa 100644
--- a/packages/ilios-common/addon/models/course.js
+++ b/packages/ilios-common/addon/models/course.js
@@ -2,7 +2,6 @@ import Model, { hasMany, belongsTo, attr } from '@ember-data/model';
 import sortableByPosition from 'ilios-common/utils/sortable-by-position';
 import { TrackedAsyncData } from 'ember-async-data';
 import { cached } from '@glimmer/tracking';
-import { map } from 'rsvp';
 import { DateTime } from 'luxon';
 import { sortBy, uniqueValues } from 'ilios-common/utils/array-helpers';
 
@@ -163,19 +162,21 @@ export default class Course extends Model {
     }
 
     return new TrackedAsyncData(
-      map(uniqueValues(this._competencyDomains.value), async (domain) => {
-        let subCompetencies = (await domain.children).filter((competency) => {
-          return this.competencies.includes(competency);
-        });
-
-        subCompetencies = sortBy(subCompetencies, 'title');
-
-        return {
-          title: domain.title,
-          id: domain.id,
-          subCompetencies,
-        };
-      }),
+      Promise.all(
+        uniqueValues(this._competencyDomains.value).map(async (domain) => {
+          let subCompetencies = (await domain.children).filter((competency) => {
+            return this.competencies.includes(competency);
+          });
+
+          subCompetencies = sortBy(subCompetencies, 'title');
+
+          return {
+            title: domain.title,
+            id: domain.id,
+            subCompetencies,
+          };
+        }),
+      ),
     );
   }
 
@@ -225,11 +226,13 @@ export default class Course extends Model {
     }
 
     return new TrackedAsyncData(
-      map(this._cohortsData.value, async (cohort) => {
-        const programYear = await cohort.programYear;
-        const program = await programYear.program;
-        return program.school;
-      }),
+      Promise.all(
+        this._cohortsData.value.map(async (cohort) => {
+          const programYear = await cohort.programYear;
+          const program = await programYear.program;
+          return program.school;
+        }),
+      ),
     );
   }
 
diff --git a/packages/ilios-common/addon/models/learner-group.js b/packages/ilios-common/addon/models/learner-group.js
index f054dfed87..6756f41ba0 100644
--- a/packages/ilios-common/addon/models/learner-group.js
+++ b/packages/ilios-common/addon/models/learner-group.js
@@ -1,6 +1,5 @@
 import Model, { hasMany, belongsTo, attr } from '@ember-data/model';
 import escapeRegExp from 'ilios-common/utils/escape-reg-exp';
-import { map } from 'rsvp';
 import { TrackedAsyncData } from 'ember-async-data';
 import { cached } from '@glimmer/tracking';
 import { mapBy, uniqueValues } from 'ilios-common/utils/array-helpers';
@@ -190,9 +189,11 @@ export default class LearnerGroup extends Model {
 
   async getAllDescendants() {
     const children = await this.children;
-    const childDescendants = await map(children, (child) => {
-      return child.getAllDescendants();
-    });
+    const childDescendants = await Promise.all(
+      children.map((child) => {
+        return child.getAllDescendants();
+      }),
+    );
 
     return [...children, ...childDescendants.flat()];
   }
@@ -448,13 +449,15 @@ export default class LearnerGroup extends Model {
   async removeUserFromGroupAndAllDescendants({ id: userId }) {
     const allDescendants = await this.getAllDescendants();
     const groups = [this, ...allDescendants].reverse();
-    return await map(groups, async (group) => {
-      if (group.hasMany('users').ids().includes(userId)) {
-        group.users = (await group.users).filter(({ id }) => id !== userId);
-      }
+    return await Promise.all(
+      groups.map(async (group) => {
+        if (group.hasMany('users').ids().includes(userId)) {
+          group.users = (await group.users).filter(({ id }) => id !== userId);
+        }
 
-      return group;
-    });
+        return group;
+      }),
+    );
   }
 
   async getAllParents() {
@@ -501,12 +504,14 @@ export default class LearnerGroup extends Model {
     const allParents = await this.getAllParents();
     const groups = [...allParents, this];
 
-    const groupMap = await map(groups, async (group) => {
-      if (!group.hasMany('users').ids().includes(user.id)) {
-        (await group.users).push(user);
-        return group;
-      }
-    });
+    const groupMap = await Promise.all(
+      groups.map(async (group) => {
+        if (!group.hasMany('users').ids().includes(user.id)) {
+          (await group.users).push(user);
+          return group;
+        }
+      }),
+    );
 
     //remove groups that weren't updated (they're undefined in this array)
     return groupMap.filter(Boolean);
diff --git a/packages/ilios-common/addon/routes/course-visualize-instructor.js b/packages/ilios-common/addon/routes/course-visualize-instructor.js
index 53d3abe92d..a6891b8eaf 100644
--- a/packages/ilios-common/addon/routes/course-visualize-instructor.js
+++ b/packages/ilios-common/addon/routes/course-visualize-instructor.js
@@ -1,6 +1,5 @@
 import { service } from '@ember/service';
 import Route from '@ember/routing/route';
-import { map } from 'rsvp';
 
 export default class CourseVisualizeInstructorRoute extends Route {
   @service store;
@@ -13,7 +12,8 @@ export default class CourseVisualizeInstructorRoute extends Route {
   }
 
   async afterModel({ course }) {
-    return await Promise.all([course.school, map(course.sessions, (s) => s.sessionType)]);
+    const sessions = await course.sessions;
+    return await Promise.all([course.school, ...sessions.map((s) => s.sessionType)]);
   }
 
   beforeModel(transition) {
diff --git a/packages/ilios-common/addon/routes/course-visualize-instructors.js b/packages/ilios-common/addon/routes/course-visualize-instructors.js
index b394ad9a29..53c35dfd33 100644
--- a/packages/ilios-common/addon/routes/course-visualize-instructors.js
+++ b/packages/ilios-common/addon/routes/course-visualize-instructors.js
@@ -1,6 +1,5 @@
 import { service } from '@ember/service';
 import Route from '@ember/routing/route';
-import { map } from 'rsvp';
 
 export default class CourseVisualizeInstructorsRoute extends Route {
   @service store;
@@ -14,9 +13,9 @@ export default class CourseVisualizeInstructorsRoute extends Route {
   async afterModel(course) {
     const sessions = await course.sessions;
     return await Promise.all([
-      map(sessions, (s) => s.offerings),
-      map(sessions, (s) => s.totalSumDuration),
-      map(sessions, (s) => s.allInstructors),
+      ...sessions.map((s) => s.offerings),
+      ...sessions.map((s) => s.totalSumDuration),
+      ...sessions.map((s) => s.allInstructors),
     ]);
   }
 
diff --git a/packages/ilios-common/addon/routes/course-visualize-objectives.js b/packages/ilios-common/addon/routes/course-visualize-objectives.js
index a7e209b36d..84347832af 100644
--- a/packages/ilios-common/addon/routes/course-visualize-objectives.js
+++ b/packages/ilios-common/addon/routes/course-visualize-objectives.js
@@ -1,6 +1,5 @@
 import { service } from '@ember/service';
 import Route from '@ember/routing/route';
-import { map } from 'rsvp';
 
 export default class CourseVisualizeObjectivesRoute extends Route {
   @service store;
@@ -13,7 +12,7 @@ export default class CourseVisualizeObjectivesRoute extends Route {
 
   async afterModel(course) {
     const sessions = await course.sessions;
-    return await Promise.all([course.objectives, map(sessions, (s) => s.objectives)]);
+    return await Promise.all([course.objectives, ...sessions.map((s) => s.objectives)]);
   }
 
   beforeModel(transition) {
diff --git a/packages/ilios-common/addon/routes/course-visualize-session-type.js b/packages/ilios-common/addon/routes/course-visualize-session-type.js
index bc24dabd7a..5fb3105f5c 100644
--- a/packages/ilios-common/addon/routes/course-visualize-session-type.js
+++ b/packages/ilios-common/addon/routes/course-visualize-session-type.js
@@ -1,6 +1,5 @@
 import { service } from '@ember/service';
 import Route from '@ember/routing/route';
-import { map } from 'rsvp';
 
 export default class CourseVisualizeSessionTypeRoute extends Route {
   @service store;
@@ -16,9 +15,9 @@ export default class CourseVisualizeSessionTypeRoute extends Route {
   async afterModel({ course }) {
     const sessions = await course.sessions;
     return await Promise.all([
-      map(sessions, (s) => s.sessionType),
-      map(sessions, (s) => s.terms),
-      map(sessions, (s) => s.totalSumDuration),
+      ...sessions.map((s) => s.sessionType),
+      ...sessions.map((s) => s.terms),
+      ...sessions.map((s) => s.totalSumDuration),
     ]);
   }
 
diff --git a/packages/ilios-common/addon/routes/course-visualize-session-types.js b/packages/ilios-common/addon/routes/course-visualize-session-types.js
index 953c804ff8..d51cb96b61 100644
--- a/packages/ilios-common/addon/routes/course-visualize-session-types.js
+++ b/packages/ilios-common/addon/routes/course-visualize-session-types.js
@@ -1,6 +1,5 @@
 import { service } from '@ember/service';
 import Route from '@ember/routing/route';
-import { map } from 'rsvp';
 
 export default class CourseVisualizeSessionTypesRoute extends Route {
   @service store;
@@ -13,7 +12,7 @@ export default class CourseVisualizeSessionTypesRoute extends Route {
 
   async afterModel(course) {
     const sessions = await course.sessions;
-    return await map(sessions, (s) => s.sessionType);
+    return await Promise.all(sessions.map((s) => s.sessionType));
   }
 
   beforeModel(transition) {
diff --git a/packages/ilios-common/addon/routes/course-visualize-term.js b/packages/ilios-common/addon/routes/course-visualize-term.js
index 0abe21187d..fa0576df00 100644
--- a/packages/ilios-common/addon/routes/course-visualize-term.js
+++ b/packages/ilios-common/addon/routes/course-visualize-term.js
@@ -1,6 +1,5 @@
 import { service } from '@ember/service';
 import Route from '@ember/routing/route';
-import { map } from 'rsvp';
 
 export default class CourseVisualizeTermRoute extends Route {
   @service store;
@@ -17,8 +16,8 @@ export default class CourseVisualizeTermRoute extends Route {
     const sessions = await course.sessions;
     return await Promise.all([
       term.vocabulary,
-      map(sessions, (s) => s.sessionType),
-      map(sessions, (s) => s.totalSumDuration),
+      ...sessions.map((s) => s.sessionType),
+      ...sessions.map((s) => s.totalSumDuration),
     ]);
   }
 
diff --git a/packages/ilios-common/addon/routes/course-visualize-vocabularies.js b/packages/ilios-common/addon/routes/course-visualize-vocabularies.js
index f123cf9a9f..169c6e715d 100644
--- a/packages/ilios-common/addon/routes/course-visualize-vocabularies.js
+++ b/packages/ilios-common/addon/routes/course-visualize-vocabularies.js
@@ -1,6 +1,5 @@
 import { service } from '@ember/service';
 import Route from '@ember/routing/route';
-import { map } from 'rsvp';
 
 export default class CourseVisualizeVocabulariesRoute extends Route {
   @service store;
@@ -13,7 +12,7 @@ export default class CourseVisualizeVocabulariesRoute extends Route {
 
   async afterModel(course) {
     const sessions = await course.sessions;
-    return await Promise.all([course.get('school'), map(sessions, (s) => s.terms)]);
+    return await Promise.all([course.school, ...sessions.map((s) => s.terms)]);
   }
 
   beforeModel(transition) {
diff --git a/packages/ilios-common/addon/routes/course-visualize-vocabulary.js b/packages/ilios-common/addon/routes/course-visualize-vocabulary.js
index 54981f9ea0..ab4f01e0f6 100644
--- a/packages/ilios-common/addon/routes/course-visualize-vocabulary.js
+++ b/packages/ilios-common/addon/routes/course-visualize-vocabulary.js
@@ -1,6 +1,5 @@
 import { service } from '@ember/service';
 import Route from '@ember/routing/route';
-import { map } from 'rsvp';
 
 export default class CourseVisualizeVocabularyRoute extends Route {
   @service store;
@@ -16,11 +15,7 @@ export default class CourseVisualizeVocabularyRoute extends Route {
   async afterModel(model) {
     const { course, vocabulary } = model;
     const sessions = await course.sessions;
-    return await Promise.all([
-      course.get('school'),
-      vocabulary.terms,
-      map(sessions, (s) => s.terms),
-    ]);
+    return await Promise.all([course.school, vocabulary.terms, ...sessions.map((s) => s.terms)]);
   }
 
   beforeModel(transition) {