diff --git a/src/app/beta/orgs/[orgId]/canvassassignments/[canvassAssId]/sessions/route.ts b/src/app/beta/orgs/[orgId]/canvassassignments/[canvassAssId]/sessions/route.ts
index e7796c87a..ffbd90ba6 100644
--- a/src/app/beta/orgs/[orgId]/canvassassignments/[canvassAssId]/sessions/route.ts
+++ b/src/app/beta/orgs/[orgId]/canvassassignments/[canvassAssId]/sessions/route.ts
@@ -56,7 +56,20 @@ export async function GET(request: NextRequest, { params }: RouteMeta) {
             },
             assignee: person,
             assignment: {
+              campaign: {
+                id: model.campId,
+              },
               id: model._id.toString(),
+              metrics: model.metrics.map((m) => ({
+                definesDone: m.definesDone,
+                description: m.description,
+                id: m._id,
+                kind: m.kind,
+                question: m.question,
+              })),
+              organization: {
+                id: model.orgId,
+              },
               title: model.title,
             },
           });
diff --git a/src/app/beta/orgs/[orgId]/canvassassignments/[canvassAssId]/stats/route.ts b/src/app/beta/orgs/[orgId]/canvassassignments/[canvassAssId]/stats/route.ts
index 59948ba59..568c081b4 100644
--- a/src/app/beta/orgs/[orgId]/canvassassignments/[canvassAssId]/stats/route.ts
+++ b/src/app/beta/orgs/[orgId]/canvassassignments/[canvassAssId]/stats/route.ts
@@ -68,7 +68,20 @@ export async function GET(request: NextRequest, { params }: RouteMeta) {
             },
             assignee: person,
             assignment: {
+              campaign: {
+                id: assignmentModel.campId,
+              },
               id: assignmentModel._id.toString(),
+              metrics: assignmentModel.metrics.map((m) => ({
+                definesDone: m.definesDone,
+                description: m.description,
+                id: m._id,
+                kind: m.kind,
+                question: m.question,
+              })),
+              organization: {
+                id: assignmentModel.orgId,
+              },
               title: assignmentModel.title,
             },
           });
diff --git a/src/app/beta/users/me/canvassassignments/route.ts b/src/app/beta/users/me/canvassassignments/route.ts
index c0edec3a4..1249f5f8e 100644
--- a/src/app/beta/users/me/canvassassignments/route.ts
+++ b/src/app/beta/users/me/canvassassignments/route.ts
@@ -4,9 +4,10 @@ import { NextRequest, NextResponse } from 'next/server';
 
 import BackendApiClient from 'core/api/client/BackendApiClient';
 import { CanvassAssignmentModel } from 'features/canvassAssignments/models';
-import { ZetkinCanvassSession } from 'features/canvassAssignments/types';
-import { ZetkinMembership, ZetkinPerson } from 'utils/types/zetkin';
+import { AssignmentWithAreas } from 'features/canvassAssignments/types';
+import { ZetkinMembership } from 'utils/types/zetkin';
 import { AreaModel } from 'features/areas/models';
+import { ZetkinArea } from 'features/areas/types';
 
 export async function GET(request: NextRequest) {
   const headers: IncomingHttpHeaders = {};
@@ -18,21 +19,67 @@ export async function GET(request: NextRequest) {
     `/api/users/me/memberships`
   );
 
-  const sessions: ZetkinCanvassSession[] = [];
+  const assignmentsWithAreas: AssignmentWithAreas[] = [];
 
+  //för varje organisation personen är medlem i
   for await (const membership of memberships) {
     const { id: personId } = membership.profile;
 
-    const person = await apiClient.get<ZetkinPerson>(
-      `/api/orgs/${membership.organization.id}/people/${personId}`
-    );
-
+    //plocka ut alla assignments som personen har en tilldelning i
     const assignmentModels = await CanvassAssignmentModel.find({
       orgId: membership.organization.id,
       'sessions.personId': { $eq: personId },
     });
 
+    //för varje uppdrag personen har en tilldelning i
     for await (const assignment of assignmentModels) {
+      const areas: ZetkinArea[] = [];
+
+      //för varje session i det uppdraget
+      for await (const session of assignment.sessions) {
+        //om vi är på en session som "tillhör" personen
+        if (session.personId == personId) {
+          //lägg till arean i listan över areas
+          const area = await AreaModel.findOne({
+            _id: session.areaId,
+          });
+
+          if (area) {
+            areas.push({
+              description: area.description,
+              id: area._id.toString(),
+              organization: {
+                id: area.orgId,
+              },
+              points: area.points,
+              tags: [], // TODO: is this necessary here?
+              title: area.title,
+            });
+          }
+        }
+      }
+
+      assignmentsWithAreas.push({
+        areas: areas,
+        campaign: {
+          id: assignment.campId,
+        },
+        id: assignment._id.toString(),
+        metrics: assignment.metrics.map((m) => ({
+          definesDone: m.definesDone,
+          description: m.description,
+          id: m._id.toString(),
+          kind: m.kind,
+          question: m.question,
+        })),
+        organization: {
+          id: assignment.orgId,
+        },
+        title: assignment.title,
+      });
+    }
+
+    /* for await (const assignment of assignmentModels) {
       for await (const sessionData of assignment.sessions) {
         if (sessionData.personId == personId) {
           const orgId = assignment.orgId;
@@ -42,7 +89,7 @@ export async function GET(request: NextRequest) {
           });
 
           if (area) {
-            sessions.push({
+            assignmentsWithAreas.push({
               area: {
                 description: area.description,
                 id: area._id.toString(),
@@ -55,17 +102,30 @@ export async function GET(request: NextRequest) {
               },
               assignee: person,
               assignment: {
+                campaign: {
+                  id: assignment.campId,
+                },
                 id: assignment._id.toString(),
+                metrics: assignment.metrics.map((m) => ({
+                  definesDone: m.definesDone,
+                  description: m.description,
+                  id: m._id.toString(),
+                  kind: m.kind,
+                  question: m.question,
+                })),
+                organization: {
+                  id: assignment.orgId,
+                },
                 title: assignment.title,
               },
             });
           }
         }
       }
-    }
+    } */
   }
 
   return NextResponse.json({
-    data: sessions,
+    data: assignmentsWithAreas,
   });
 }
diff --git a/src/app/my/canvassassignments/[canvassAssId]/page.tsx b/src/app/my/canvassassignments/[canvassAssId]/page.tsx
new file mode 100644
index 000000000..e456c222e
--- /dev/null
+++ b/src/app/my/canvassassignments/[canvassAssId]/page.tsx
@@ -0,0 +1,14 @@
+import 'leaflet/dist/leaflet.css';
+import MyCanvassAssignmentPage from 'features/canvassAssignments/components/MyCanvassAssignmentPage';
+
+interface PageProps {
+  params: {
+    canvassAssId: string;
+  };
+}
+
+export default function Page({ params }: PageProps) {
+  const { canvassAssId } = params;
+
+  return <MyCanvassAssignmentPage canvassAssId={canvassAssId} />;
+}
diff --git a/src/app/o/[orgId]/areas/[areaId]/page.tsx b/src/app/o/[orgId]/areas/[areaId]/page.tsx
deleted file mode 100644
index bd2a57f3c..000000000
--- a/src/app/o/[orgId]/areas/[areaId]/page.tsx
+++ /dev/null
@@ -1,23 +0,0 @@
-import 'leaflet/dist/leaflet.css';
-import { notFound } from 'next/navigation';
-
-import PublicAreaPage from 'features/canvassAssignments/components/PublicAreaPage';
-import { AREAS, hasFeature } from 'utils/featureFlags';
-
-interface PageProps {
-  params: {
-    areaId: string;
-    orgId: string;
-  };
-}
-
-export default function Page({ params }: PageProps) {
-  const { orgId, areaId } = params;
-  const hasAreas = hasFeature(AREAS, parseInt(orgId), process.env);
-
-  if (!hasAreas) {
-    return notFound();
-  }
-
-  return <PublicAreaPage areaId={areaId} orgId={parseInt(orgId)} />;
-}
diff --git a/src/features/canvassAssignments/components/PublicAreaMap.tsx b/src/features/canvassAssignments/components/CanvassAssignmentMap.tsx
similarity index 69%
rename from src/features/canvassAssignments/components/PublicAreaMap.tsx
rename to src/features/canvassAssignments/components/CanvassAssignmentMap.tsx
index 291cc9bb6..db17c477b 100644
--- a/src/features/canvassAssignments/components/PublicAreaMap.tsx
+++ b/src/features/canvassAssignments/components/CanvassAssignmentMap.tsx
@@ -1,5 +1,5 @@
 import { FC, useCallback, useEffect, useRef, useState } from 'react';
-import { LatLng, latLngBounds, Map } from 'leaflet';
+import { LatLng, Map, FeatureGroup as FeatureGroupType } from 'leaflet';
 import { makeStyles } from '@mui/styles';
 import { Add, GpsNotFixed, Remove } from '@mui/icons-material';
 import {
@@ -7,11 +7,16 @@ import {
   Button,
   Divider,
   IconButton,
+  MenuItem,
+  Select,
+  ToggleButton,
+  ToggleButtonGroup,
   Typography,
   useTheme,
 } from '@mui/material';
 import {
   AttributionControl,
+  FeatureGroup,
   MapContainer,
   Polygon,
   TileLayer,
@@ -22,9 +27,12 @@ import { DivIconMarker } from 'features/events/components/LocationModal/DivIconM
 import useCreatePlace from '../hooks/useCreatePlace';
 import usePlaces from '../hooks/usePlaces';
 import getCrosshairPositionOnMap from '../utils/getCrosshairPositionOnMap';
-import MarkerIcon from '../utils/markerIcon';
 import PlaceDialog from './PlaceDialog';
 import { CreatePlaceCard } from './CreatePlaceCard';
+import getVisitState, { ProgressState } from '../utils/getVisitState';
+import MarkerIcon from '../utils/MarkerIcon';
+import { ZetkinCanvassAssignment } from '../types';
+import getDoneState from '../utils/getDoneState';
 
 const useStyles = makeStyles((theme) => ({
   '@keyframes ghostMarkerBounce': {
@@ -55,6 +63,14 @@ const useStyles = makeStyles((theme) => ({
     transition: 'opacity 0.1s',
     zIndex: 1200,
   },
+  filterControls: {
+    display: 'flex',
+    flexDirection: 'column',
+    marginTop: 10,
+    position: 'absolute',
+    right: 10,
+    zIndex: 1000,
+  },
   ghostMarker: {
     animationDirection: 'alternate',
     animationDuration: '0.4s',
@@ -73,6 +89,12 @@ const useStyles = makeStyles((theme) => ({
     padding: '8px',
     width: '90%',
   },
+  markerFilterButtons: {
+    backgroundColor: theme.palette.common.white,
+    borderRadius: 4,
+    display: 'flex',
+    flexDirection: 'row',
+  },
   zoomControls: {
     backgroundColor: theme.palette.common.white,
     borderRadius: 2,
@@ -92,26 +114,38 @@ export type PlaceDialogStep =
   | 'wizard'
   | 'pickHousehold';
 
-type PublicAreaMapProps = {
-  area: ZetkinArea;
-  canvassAssId: string | null;
+type CanvassAssignmentMapProps = {
+  areas: ZetkinArea[];
+  assignment: ZetkinCanvassAssignment;
 };
 
-const PublicAreaMap: FC<PublicAreaMapProps> = ({ canvassAssId, area }) => {
+const CanvassAssignmentMap: FC<CanvassAssignmentMapProps> = ({
+  areas,
+  assignment,
+}) => {
   const theme = useTheme();
   const classes = useStyles();
-  const places = usePlaces(area.organization.id).data || [];
-  const createPlace = useCreatePlace(area.organization.id);
+  const places = usePlaces(assignment.organization.id).data || [];
+  const createPlace = useCreatePlace(assignment.organization.id);
 
   const [selectedPlaceId, setSelectedPlaceId] = useState<string | null>(null);
   const [anchorEl, setAnchorEl] = useState<HTMLButtonElement | null>(null);
   const [dialogStep, setDialogStep] = useState<PlaceDialogStep>('place');
   const [standingStill, setStandingStill] = useState(false);
   const [isCreating, setIsCreating] = useState(false);
+  const [placeFilters, setPlaceFilters] = useState<ProgressState[]>([
+    'all',
+    'none',
+    'some',
+  ]);
+  const [dataToShow, setDataToShow] = useState<'visited' | 'done'>('visited');
 
   const [map, setMap] = useState<Map | null>(null);
   const crosshairRef = useRef<HTMLDivElement | null>(null);
   const standingStillTimerRef = useRef(0);
+  const reactFGref = useRef<FeatureGroupType | null>(null);
+
+  const [zoomed, setZoomed] = useState(false);
 
   const selectedPlace = places.find((place) => place.id == selectedPlaceId);
   const showViewPlaceButton = !!selectedPlace && !anchorEl;
@@ -209,6 +243,32 @@ const PublicAreaMap: FC<PublicAreaMapProps> = ({ canvassAssId, area }) => {
     updateSelection();
   }, [places]);
 
+  useEffect(() => {
+    if (map && !zoomed) {
+      const bounds = reactFGref.current?.getBounds();
+      if (bounds?.isValid()) {
+        map.fitBounds(bounds);
+        setZoomed(true);
+      }
+    }
+  }, [areas, map]);
+
+  const metricThatDefinesDone = assignment.metrics.find(
+    (metric) => metric.definesDone
+  );
+
+  const filteredPlaces = places.filter((place) => {
+    const state =
+      dataToShow == 'visited'
+        ? getVisitState(place.households, assignment.id)
+        : getDoneState(
+            place.households,
+            assignment.id,
+            metricThatDefinesDone?.id || ''
+          );
+    return placeFilters.includes(state);
+  });
+
   return (
     <>
       <Box className={classes.zoomControls}>
@@ -220,6 +280,40 @@ const PublicAreaMap: FC<PublicAreaMapProps> = ({ canvassAssId, area }) => {
           <Remove />
         </IconButton>
       </Box>
+      <Box className={classes.filterControls}>
+        <ToggleButtonGroup
+          className={classes.markerFilterButtons}
+          onChange={(ev, newValue: ProgressState[]) => {
+            setPlaceFilters(newValue);
+          }}
+          value={placeFilters}
+        >
+          <ToggleButton value="none">
+            <MarkerIcon dataToShow={dataToShow} selected={false} state="none" />
+          </ToggleButton>
+          <ToggleButton value="some">
+            <MarkerIcon dataToShow={dataToShow} selected={false} state="some" />
+          </ToggleButton>
+          <ToggleButton value="all">
+            <MarkerIcon dataToShow={dataToShow} selected={false} state="all" />
+          </ToggleButton>
+        </ToggleButtonGroup>
+        {!!assignment.metrics.find((metric) => metric.definesDone) && (
+          <Select
+            onChange={(ev) => {
+              const value = ev.target.value;
+              if (value == 'done' || value == 'visited') {
+                setDataToShow(value);
+              }
+            }}
+            sx={{ backgroundColor: 'white' }}
+            value={dataToShow}
+          >
+            <MenuItem value="visited">Visited</MenuItem>
+            <MenuItem value="done">Done</MenuItem>
+          </Select>
+        )}
+      </Box>
       <Box position="relative">
         <Box
           ref={crosshairRef}
@@ -280,7 +374,6 @@ const PublicAreaMap: FC<PublicAreaMapProps> = ({ canvassAssId, area }) => {
       <MapContainer
         ref={(map) => setMap(map)}
         attributionControl={false}
-        bounds={latLngBounds(area.points)}
         minZoom={1}
         style={{ height: '100%', width: '100%' }}
         zoomControl={false}
@@ -290,9 +383,30 @@ const PublicAreaMap: FC<PublicAreaMapProps> = ({ canvassAssId, area }) => {
           attribution="<span style='color:#a3a3a3;'>Leaflet & OpenStreetMap</span>"
           url="https://tile.openstreetmap.org/{z}/{x}/{y}.png"
         />
-        <Polygon color={theme.palette.primary.main} positions={area.points} />
+        <FeatureGroup
+          ref={(fgRef) => {
+            reactFGref.current = fgRef;
+          }}
+        >
+          {areas.map((area) => (
+            <Polygon
+              key={area.id}
+              color={theme.palette.primary.main}
+              positions={area.points}
+            />
+          ))}
+        </FeatureGroup>
         <>
-          {places.map((place) => {
+          {filteredPlaces.map((place) => {
+            const state =
+              dataToShow == 'visited'
+                ? getVisitState(place.households, assignment.id)
+                : getDoneState(
+                    place.households,
+                    assignment.id,
+                    metricThatDefinesDone?.id || ''
+                  );
+
             const selected = place.id == selectedPlaceId;
             const key = `marker-${place.id}-${selected.toString()}`;
 
@@ -310,15 +424,19 @@ const PublicAreaMap: FC<PublicAreaMapProps> = ({ canvassAssId, area }) => {
                   lng: place.position.lng,
                 }}
               >
-                <MarkerIcon selected={selected} />
+                <MarkerIcon
+                  dataToShow={dataToShow}
+                  selected={selected}
+                  state={state}
+                />
               </DivIconMarker>
             );
           })}
         </>
       </MapContainer>
-      {selectedPlace && canvassAssId && (
+      {selectedPlace && (
         <PlaceDialog
-          canvassAssId={canvassAssId}
+          canvassAssId={assignment.id}
           dialogStep={dialogStep}
           onClose={() => {
             setAnchorEl(null);
@@ -330,7 +448,7 @@ const PublicAreaMap: FC<PublicAreaMapProps> = ({ canvassAssId, area }) => {
           onUpdateDone={() => setDialogStep('place')}
           onWizard={() => setDialogStep('wizard')}
           open={!!anchorEl}
-          orgId={area.organization.id}
+          orgId={assignment.organization.id}
           place={selectedPlace}
         />
       )}
@@ -363,4 +481,4 @@ const PublicAreaMap: FC<PublicAreaMapProps> = ({ canvassAssId, area }) => {
   );
 };
 
-export default PublicAreaMap;
+export default CanvassAssignmentMap;
diff --git a/src/features/canvassAssignments/components/MyCanvassAssignmentPage.tsx b/src/features/canvassAssignments/components/MyCanvassAssignmentPage.tsx
new file mode 100644
index 000000000..c6daab6c3
--- /dev/null
+++ b/src/features/canvassAssignments/components/MyCanvassAssignmentPage.tsx
@@ -0,0 +1,77 @@
+'use client';
+
+import dynamic from 'next/dynamic';
+import { FC } from 'react';
+import { Avatar, Box } from '@mui/material';
+
+import useOrganization from 'features/organizations/hooks/useOrganization';
+import ZUIFutures from 'zui/ZUIFutures';
+import useServerSide from 'core/useServerSide';
+import useMyCanvassAssignments from '../hooks/useMyCanvassAssignments';
+import { AssignmentWithAreas } from '../types';
+
+const CanvassAssignmentMap = dynamic(() => import('./CanvassAssignmentMap'), {
+  ssr: false,
+});
+
+const AssignmentPage: FC<{ assignment: AssignmentWithAreas }> = ({
+  assignment,
+}) => {
+  const orgFuture = useOrganization(assignment.organization.id);
+  const isServer = useServerSide();
+
+  if (isServer) {
+    return null;
+  }
+  return (
+    <ZUIFutures futures={{ org: orgFuture }}>
+      {({ data: { org } }) => (
+        <>
+          <Box
+            alignItems="center"
+            display="flex"
+            gap={1}
+            height="10vh"
+            justifyContent="space-between"
+            padding={2}
+          >
+            <Box alignItems="center" display="flex" gap={1}>
+              <Avatar src={`/api/orgs/${org.id}/avatar`} />
+              {org.title}
+            </Box>
+            <Box alignItems="flex-end" display="flex" flexDirection="column">
+              {assignment.title ?? 'Untitled canvassassignment'}
+            </Box>
+          </Box>
+          <Box height="90vh">
+            <CanvassAssignmentMap
+              areas={assignment.areas}
+              assignment={assignment}
+            />
+          </Box>
+        </>
+      )}
+    </ZUIFutures>
+  );
+};
+
+type MyCanvassAssignmentPageProps = {
+  canvassAssId: string;
+};
+
+const MyCanvassAssignmentPage: FC<MyCanvassAssignmentPageProps> = ({
+  canvassAssId,
+}) => {
+  const myAssignments = useMyCanvassAssignments().data || [];
+  const assignment = myAssignments.find(
+    (assignment) => assignment.id == canvassAssId
+  );
+
+  if (!assignment) {
+    return null;
+  }
+
+  return <AssignmentPage assignment={assignment} />;
+};
+
+export default MyCanvassAssignmentPage;
diff --git a/src/features/canvassAssignments/components/MyCanvassAssignmentsPage.tsx b/src/features/canvassAssignments/components/MyCanvassAssignmentsPage.tsx
index 71d384fa7..1e129d81f 100644
--- a/src/features/canvassAssignments/components/MyCanvassAssignmentsPage.tsx
+++ b/src/features/canvassAssignments/components/MyCanvassAssignmentsPage.tsx
@@ -11,17 +11,15 @@ import {
   Typography,
 } from '@mui/material';
 
-import useMyCanvassSessions from '../hooks/useMyCanvassSessions';
+import useMyCanvassAssignments from '../hooks/useMyCanvassAssignments';
 import useCanvassAssignment from '../hooks/useCanvassAssignment';
 import useOrganization from 'features/organizations/hooks/useOrganization';
 import ZUIFutures from 'zui/ZUIFutures';
-import { ZetkinCanvassSession } from '../types';
 
 const CanvassAssignmentCard: FC<{
-  areaId: string;
   assignmentId: string;
   orgId: number;
-}> = ({ areaId, orgId, assignmentId }) => {
+}> = ({ orgId, assignmentId }) => {
   const router = useRouter();
   const assignmentFuture = useCanvassAssignment(orgId, assignmentId);
   const organizationFuture = useOrganization(orgId);
@@ -44,9 +42,7 @@ const CanvassAssignmentCard: FC<{
           <CardActions>
             <Button
               onClick={() =>
-                router.push(
-                  `/o/${orgId}/areas/${areaId}?canvassAssId=${assignment.id}`
-                )
+                router.push(`/my/canvassassignments/${assignment.id}`)
               }
               variant="outlined"
             >
@@ -60,27 +56,17 @@ const CanvassAssignmentCard: FC<{
 };
 
 const MyCanvassAssignmentsPage: FC = () => {
-  const mySessions = useMyCanvassSessions().data || [];
-
-  const sessionsByAssignmentId: Record<string, ZetkinCanvassSession[]> = {};
-  mySessions.forEach((session) => {
-    if (!sessionsByAssignmentId[session.assignment.id]) {
-      sessionsByAssignmentId[session.assignment.id] = [session];
-    } else {
-      sessionsByAssignmentId[session.assignment.id].push(session);
-    }
-  });
+  const myAssignments = useMyCanvassAssignments().data || [];
 
   return (
     <Box display="flex" flexDirection="column" gap={2} padding={1}>
       <Typography variant="h6">Canvassing</Typography>
-      {Object.values(sessionsByAssignmentId).map((sessions) => {
+      {myAssignments.map((assignment) => {
         return (
           <CanvassAssignmentCard
-            key={sessions[0].assignment.id}
-            areaId={sessions[0].area.id}
-            assignmentId={sessions[0].assignment.id}
-            orgId={sessions[0].area.organization.id}
+            key={assignment.id}
+            assignmentId={assignment.id}
+            orgId={assignment.organization.id}
           />
         );
       })}
diff --git a/src/features/canvassAssignments/components/PlaceDialog/Household.tsx b/src/features/canvassAssignments/components/PlaceDialog/Household.tsx
index 88fa9aff9..70faf925a 100644
--- a/src/features/canvassAssignments/components/PlaceDialog/Household.tsx
+++ b/src/features/canvassAssignments/components/PlaceDialog/Household.tsx
@@ -10,7 +10,7 @@ type HouseholdProps = {
   onHouseholdTitleChange: (newTitle: string) => void;
   onHouseholdUpdate: (data: HouseholdPatchBody) => void;
   onWizardStart: () => void;
-  visitedRecently: boolean;
+  visitedInThisAssignment: boolean;
 };
 
 const Household: FC<HouseholdProps> = ({
@@ -20,7 +20,7 @@ const Household: FC<HouseholdProps> = ({
   onEditHouseholdTitleEnd,
   onHouseholdUpdate,
   onWizardStart,
-  visitedRecently,
+  visitedInThisAssignment,
 }) => {
   return (
     <Box
@@ -60,13 +60,9 @@ const Household: FC<HouseholdProps> = ({
         justifyContent="flex-end"
         overflow="hidden"
       >
-        {visitedRecently &&
-          'This household has been visted within the past 24 hours.'}
-        <Button
-          disabled={visitedRecently}
-          onClick={onWizardStart}
-          variant="contained"
-        >
+        {visitedInThisAssignment &&
+          'This household has been visted in this assignment.'}
+        <Button onClick={onWizardStart} variant="contained">
           Log visit
         </Button>
 
diff --git a/src/features/canvassAssignments/components/PlaceDialog/Place.tsx b/src/features/canvassAssignments/components/PlaceDialog/Place.tsx
index 8fcc054b1..effebd903 100644
--- a/src/features/canvassAssignments/components/PlaceDialog/Place.tsx
+++ b/src/features/canvassAssignments/components/PlaceDialog/Place.tsx
@@ -1,9 +1,8 @@
-import { Check } from '@mui/icons-material';
 import { Box, Divider, Typography } from '@mui/material';
 import { FC } from 'react';
 
-import { isWithinLast24Hours } from 'features/canvassAssignments/utils/isWithinLast24Hours';
 import { ZetkinPlace } from 'features/canvassAssignments/types';
+import ZUIRelativeTime from 'zui/ZUIRelativeTime';
 
 type PlaceProps = {
   onSelectHousehold: (householdId: string) => void;
@@ -36,32 +35,33 @@ const Place: FC<PlaceProps> = ({ onSelectHousehold, place }) => {
           {`${place.households.length} household/s`}
         </Typography>
         <Divider />
-        <Box display="flex" flexDirection="column" sx={{ overflowY: 'auto' }}>
+        <Box
+          display="flex"
+          flexDirection="column"
+          gap={2}
+          sx={{ overflowY: 'auto' }}
+        >
           {place.households.map((household) => {
-            const visitedRecently = isWithinLast24Hours(
-              household.visits.map((t) => t.timestamp)
-            );
-            /*const mostRecentVisit = household.visits.toSorted(
-          (a, b) => {
-            const dateA = new Date(a.timestamp);
-            const dateB = new Date(b.timestamp);
-            if (dateA > dateB) {
-              return -1;
-            } else if (dateB > dateA) {
-              return 1;
-            } else {
-              return 0;
-            }
-          }
-        )[0];*/
+            const sortedVisits = household.visits.toSorted((a, b) => {
+              const dateA = new Date(a.timestamp);
+              const dateB = new Date(b.timestamp);
+              if (dateA > dateB) {
+                return -1;
+              } else if (dateB > dateA) {
+                return 1;
+              } else {
+                return 0;
+              }
+            });
+
+            const mostRecentVisit =
+              sortedVisits.length > 0 ? sortedVisits[0] : null;
 
             return (
               <Box
                 key={household.id}
                 alignItems="center"
                 display="flex"
-                mb={1}
-                mt={1}
                 onClick={() => {
                   onSelectHousehold(household.id);
                 }}
@@ -70,7 +70,9 @@ const Place: FC<PlaceProps> = ({ onSelectHousehold, place }) => {
                 <Box flexGrow={1}>
                   {household.title || 'Untitled household'}
                 </Box>
-                {visitedRecently ? <Check color="secondary" /> : ''}
+                {mostRecentVisit && (
+                  <ZUIRelativeTime datetime={mostRecentVisit.timestamp} />
+                )}
               </Box>
             );
           })}
diff --git a/src/features/canvassAssignments/components/PlaceDialog/index.tsx b/src/features/canvassAssignments/components/PlaceDialog/index.tsx
index 4db5fc320..0833e1487 100644
--- a/src/features/canvassAssignments/components/PlaceDialog/index.tsx
+++ b/src/features/canvassAssignments/components/PlaceDialog/index.tsx
@@ -1,10 +1,4 @@
-import {
-  ArrowBackIos,
-  Check,
-  Close,
-  Edit,
-  MoreVert,
-} from '@mui/icons-material';
+import { ArrowBackIos, Close, Edit, MoreVert } from '@mui/icons-material';
 import { FC, useState } from 'react';
 import {
   Box,
@@ -22,12 +16,12 @@ import VisitWizard from './VisitWizard';
 import EditPlace from './EditPlace';
 import Place from './Place';
 import Household from './Household';
-import { isWithinLast24Hours } from 'features/canvassAssignments/utils/isWithinLast24Hours';
 import ZUIFuture from 'zui/ZUIFuture';
-import { PlaceDialogStep } from '../PublicAreaMap';
+import { PlaceDialogStep } from '../CanvassAssignmentMap';
 import { ZetkinPlace } from 'features/canvassAssignments/types';
 import usePlaceMutations from 'features/canvassAssignments/hooks/usePlaceMutations';
 import useCanvassAssignment from 'features/canvassAssignments/hooks/useCanvassAssignment';
+import ZUIRelativeTime from 'zui/ZUIRelativeTime';
 
 type PlaceDialogProps = {
   canvassAssId: string;
@@ -135,7 +129,7 @@ const PlaceDialog: FC<PlaceDialogProps> = ({
                     >
                       <ArrowBackIos />
                     </IconButton>
-                    <Typography variant="h6">Log visit</Typography>
+                    <Typography variant="h6">Pick household</Typography>
                   </Box>
                   <IconButton onClick={onClose}>
                     <Close />
@@ -206,38 +200,61 @@ const PlaceDialog: FC<PlaceDialogProps> = ({
                 />
               )}
               {dialogStep == 'pickHousehold' && (
-                <Box>
-                  <Typography variant="h6">Choose household</Typography>
-                  {place.households.map((household) => {
-                    const visitedRecently = isWithinLast24Hours(
-                      household.visits.map((t) => t.timestamp)
-                    );
-                    return (
-                      <Box
-                        key={household.id}
-                        alignItems="center"
-                        display="flex"
-                        mb={1}
-                        mt={1}
-                        onClick={() => {
-                          if (!visitedRecently) {
+                <Box
+                  display="flex"
+                  flexDirection="column"
+                  flexGrow={2}
+                  gap={1}
+                  overflow="hidden"
+                  paddingTop={1}
+                >
+                  <Box
+                    display="flex"
+                    flexDirection="column"
+                    gap={2}
+                    sx={{ overflowY: 'auto' }}
+                  >
+                    {place.households.map((household) => {
+                      const sortedVisits = household.visits.toSorted((a, b) => {
+                        const dateA = new Date(a.timestamp);
+                        const dateB = new Date(b.timestamp);
+                        if (dateA > dateB) {
+                          return -1;
+                        } else if (dateB > dateA) {
+                          return 1;
+                        } else {
+                          return 0;
+                        }
+                      });
+
+                      const mostRecentVisit =
+                        sortedVisits.length > 0 ? sortedVisits[0] : null;
+
+                      return (
+                        <Box
+                          key={household.id}
+                          alignItems="center"
+                          display="flex"
+                          onClick={() => {
                             setSelectedHouseholdId(household.id);
                             onWizard();
-                          }
-                        }}
-                        width="100%"
-                      >
-                        <Box flexGrow={1}>
-                          <Typography
-                            color={visitedRecently ? 'secondary' : ''}
-                          >
-                            {household.title || 'Untitled household'}
-                          </Typography>
+                          }}
+                          width="100%"
+                        >
+                          <Box flexGrow={1}>
+                            <Typography>
+                              {household.title || 'Untitled household'}
+                            </Typography>
+                          </Box>
+                          {mostRecentVisit && (
+                            <ZUIRelativeTime
+                              datetime={mostRecentVisit.timestamp}
+                            />
+                          )}
                         </Box>
-                        {visitedRecently ? <Check color="secondary" /> : ''}
-                      </Box>
-                    );
-                  })}
+                      );
+                    })}
+                  </Box>
                 </Box>
               )}
               {dialogStep === 'edit' && (
@@ -266,8 +283,8 @@ const PlaceDialog: FC<PlaceDialogProps> = ({
                   onWizardStart={() => {
                     onWizard();
                   }}
-                  visitedRecently={isWithinLast24Hours(
-                    selectedHousehold.visits.map((t) => t.timestamp)
+                  visitedInThisAssignment={selectedHousehold.visits.some(
+                    (visit) => visit.canvassAssId == canvassAssId
                   )}
                 />
               )}
diff --git a/src/features/canvassAssignments/components/PublicAreaPage.tsx b/src/features/canvassAssignments/components/PublicAreaPage.tsx
deleted file mode 100644
index 2d0394040..000000000
--- a/src/features/canvassAssignments/components/PublicAreaPage.tsx
+++ /dev/null
@@ -1,64 +0,0 @@
-'use client';
-
-import { Avatar, Box, Typography } from '@mui/material';
-import { FC } from 'react';
-import dynamic from 'next/dynamic';
-import { useSearchParams } from 'next/navigation';
-
-import useArea from '../../areas/hooks/useArea';
-import useOrganization from 'features/organizations/hooks/useOrganization';
-import ZUIFutures from 'zui/ZUIFutures';
-import useServerSide from 'core/useServerSide';
-
-const PublicAreaMap = dynamic(() => import('./PublicAreaMap'), { ssr: false });
-
-type PublicAreaPageProps = {
-  areaId: string;
-  orgId: number;
-};
-
-const PublicAreaPage: FC<PublicAreaPageProps> = ({ areaId, orgId }) => {
-  const orgFuture = useOrganization(orgId);
-  const areaFuture = useArea(orgId, areaId);
-  const searchParams = useSearchParams();
-
-  const canvassAssId = searchParams?.get('canvassAssId') || null;
-
-  const isServer = useServerSide();
-  if (isServer) {
-    return null;
-  }
-
-  return (
-    <ZUIFutures futures={{ area: areaFuture, org: orgFuture }}>
-      {({ data: { area, org } }) => (
-        <>
-          <Box
-            alignItems="center"
-            display="flex"
-            gap={1}
-            height="10vh"
-            justifyContent="space-between"
-            padding={2}
-          >
-            <Box alignItems="center" display="flex" gap={1}>
-              <Avatar src={`/api/orgs/${orgId}/avatar`} />
-              {org.title}
-            </Box>
-            <Box alignItems="flex-end" display="flex" flexDirection="column">
-              {area.title ?? 'Untitled canvassassignment'}
-              <Typography color="secondary" variant="body2">
-                {area.description ?? 'Untitled area'}
-              </Typography>
-            </Box>
-          </Box>
-          <Box height="90vh">
-            <PublicAreaMap area={area} canvassAssId={canvassAssId} />
-          </Box>
-        </>
-      )}
-    </ZUIFutures>
-  );
-};
-
-export default PublicAreaPage;
diff --git a/src/features/canvassAssignments/hooks/useMyCanvassSessions.ts b/src/features/canvassAssignments/hooks/useMyCanvassAssignments.ts
similarity index 66%
rename from src/features/canvassAssignments/hooks/useMyCanvassSessions.ts
rename to src/features/canvassAssignments/hooks/useMyCanvassAssignments.ts
index aa9776560..ee5564242 100644
--- a/src/features/canvassAssignments/hooks/useMyCanvassSessions.ts
+++ b/src/features/canvassAssignments/hooks/useMyCanvassAssignments.ts
@@ -1,21 +1,19 @@
 import { loadListIfNecessary } from 'core/caching/cacheUtils';
 import { useApiClient, useAppDispatch, useAppSelector } from 'core/hooks';
 import { myAssignmentsLoad, myAssignmentsLoaded } from '../store';
-import { ZetkinCanvassSession } from '../types';
+import { AssignmentWithAreas } from '../types';
 
-export default function useMyCanvassSessions() {
+export default function useMyCanvassAssignments() {
   const apiClient = useApiClient();
   const dispatch = useAppDispatch();
   const mySessions = useAppSelector(
-    (state) => state.canvassAssignments.mySessionsList
+    (state) => state.canvassAssignments.myAssignmentsWithAreasList
   );
 
   return loadListIfNecessary(mySessions, dispatch, {
     actionOnLoad: () => myAssignmentsLoad(),
     actionOnSuccess: (data) => myAssignmentsLoaded(data),
     loader: () =>
-      apiClient.get<ZetkinCanvassSession[]>(
-        '/beta/users/me/canvassassignments'
-      ),
+      apiClient.get<AssignmentWithAreas[]>('/beta/users/me/canvassassignments'),
   });
 }
diff --git a/src/features/canvassAssignments/store.ts b/src/features/canvassAssignments/store.ts
index f135aa31c..56ffa6669 100644
--- a/src/features/canvassAssignments/store.ts
+++ b/src/features/canvassAssignments/store.ts
@@ -13,6 +13,7 @@ import {
   ZetkinCanvassAssignment,
   ZetkinCanvassSession,
   ZetkinPlace,
+  AssignmentWithAreas,
 } from './types';
 
 export interface CanvassAssignmentsStoreSlice {
@@ -25,7 +26,7 @@ export interface CanvassAssignmentsStoreSlice {
     string,
     RemoteList<ZetkinCanvassAssignee>
   >;
-  mySessionsList: RemoteList<ZetkinCanvassSession & { id: string }>;
+  myAssignmentsWithAreasList: RemoteList<AssignmentWithAreas>;
   placeList: RemoteList<ZetkinPlace>;
   statsByCanvassAssId: Record<
     string,
@@ -36,7 +37,7 @@ export interface CanvassAssignmentsStoreSlice {
 const initialState: CanvassAssignmentsStoreSlice = {
   assigneesByCanvassAssignmentId: {},
   canvassAssignmentList: remoteList(),
-  mySessionsList: remoteList(),
+  myAssignmentsWithAreasList: remoteList(),
   placeList: remoteList(),
   sessionsByAssignmentId: {},
   statsByCanvassAssId: {},
@@ -220,23 +221,20 @@ const canvassAssignmentSlice = createSlice({
         new Date().toISOString();
     },
     myAssignmentsLoad: (state) => {
-      state.mySessionsList.isLoading = true;
+      state.myAssignmentsWithAreasList.isLoading = true;
     },
     myAssignmentsLoaded: (
       state,
-      action: PayloadAction<ZetkinCanvassSession[]>
+      action: PayloadAction<AssignmentWithAreas[]>
     ) => {
-      const sessions = action.payload;
+      const assignments = action.payload;
       const timestamp = new Date().toISOString();
 
-      state.mySessionsList = remoteList(
-        sessions.map((session) => ({
-          ...session,
-          id: `${session.assignment.id} ${session.assignee.id}`,
-        }))
+      state.myAssignmentsWithAreasList = remoteList(assignments);
+      state.myAssignmentsWithAreasList.loaded = timestamp;
+      state.myAssignmentsWithAreasList.items.forEach(
+        (item) => (item.loaded = timestamp)
       );
-      state.mySessionsList.loaded = timestamp;
-      state.mySessionsList.items.forEach((item) => (item.loaded = timestamp));
     },
     placeCreated: (state, action: PayloadAction<ZetkinPlace>) => {
       const place = action.payload;
diff --git a/src/features/canvassAssignments/types.ts b/src/features/canvassAssignments/types.ts
index 814def005..332f5a793 100644
--- a/src/features/canvassAssignments/types.ts
+++ b/src/features/canvassAssignments/types.ts
@@ -21,6 +21,10 @@ export type ZetkinCanvassAssignment = {
   title: string | null;
 };
 
+export type AssignmentWithAreas = ZetkinCanvassAssignment & {
+  areas: ZetkinArea[];
+};
+
 export type ZetkinCanvassAssignmentPostBody = Partial<
   Omit<ZetkinCanvassAssignment, 'id' | 'campaign' | 'organization' | 'metrics'>
 > & {
@@ -73,10 +77,7 @@ export type ZetkinPlacePatchBody = Partial<
 export type ZetkinCanvassSession = {
   area: ZetkinArea;
   assignee: ZetkinPerson;
-  assignment: {
-    id: string;
-    title: string | null;
-  };
+  assignment: ZetkinCanvassAssignment;
 };
 
 export type ZetkinCanvassSessionPostBody = {
diff --git a/src/features/canvassAssignments/utils/MarkerIcon.tsx b/src/features/canvassAssignments/utils/MarkerIcon.tsx
new file mode 100644
index 000000000..5a76b50ca
--- /dev/null
+++ b/src/features/canvassAssignments/utils/MarkerIcon.tsx
@@ -0,0 +1,56 @@
+import { FC } from 'react';
+import { useTheme } from '@mui/styles';
+import { lighten } from '@mui/system';
+
+import { ProgressState } from './getVisitState';
+
+interface MarkerIconProps {
+  dataToShow?: 'done' | 'visited';
+  state?: ProgressState;
+  selected: boolean;
+}
+
+const MarkerIcon: FC<MarkerIconProps> = ({
+  dataToShow = 'visited',
+  state = 'none',
+  selected,
+}) => {
+  const theme = useTheme();
+
+  const circleColors: Record<ProgressState, string> = {
+    all:
+      dataToShow == 'visited'
+        ? theme.palette.primary.main
+        : theme.palette.success.main,
+    none: theme.palette.grey[400],
+    some:
+      dataToShow == 'visited'
+        ? lighten(theme.palette.primary.main, 0.5)
+        : lighten(theme.palette.success.main, 0.5),
+  };
+
+  return (
+    <svg
+      fill="none"
+      height="30"
+      viewBox="0 0 21 30"
+      width="21"
+      xmlns="http://www.w3.org/2000/svg"
+    >
+      <path
+        d="M10.5 0C4.695 0 0 4.695 0 10.5C0 18.375 10.5 30 10.5 30C10.5 30 21 18.375 21 10.5C21 4.695 16.305 0 10.5 0Z"
+        fill={selected ? '#ED1C55' : '#848484'}
+      />
+      <circle className="hole" cx="10.5" cy="10.5" fill="white" r="8.5" />
+      <circle
+        className="state-dot"
+        cx="10.5"
+        cy="10.5"
+        fill={circleColors[state]}
+        r="6.5"
+      />
+    </svg>
+  );
+};
+
+export default MarkerIcon;
diff --git a/src/features/canvassAssignments/utils/getDoneState.ts b/src/features/canvassAssignments/utils/getDoneState.ts
new file mode 100644
index 000000000..215e67fe3
--- /dev/null
+++ b/src/features/canvassAssignments/utils/getDoneState.ts
@@ -0,0 +1,38 @@
+import { Household } from '../types';
+import { ProgressState } from './getVisitState';
+
+export default function getDoneState(
+  households: Household[],
+  canvassAssId: string,
+  metricId: string
+): ProgressState {
+  let numberOfDoneHouseholds = 0;
+  households.forEach((household) => {
+    household.visits.forEach((visit) => {
+      if (visit.canvassAssId == canvassAssId) {
+        const done = visit.responses.find(
+          (response) =>
+            response.metricId == metricId && response.response == 'yes'
+        );
+
+        if (done) {
+          numberOfDoneHouseholds++;
+        }
+      }
+    });
+  });
+
+  if (
+    numberOfDoneHouseholds > 0 &&
+    numberOfDoneHouseholds == households.length
+  ) {
+    return 'all';
+  } else if (
+    numberOfDoneHouseholds > 0 &&
+    numberOfDoneHouseholds < households.length
+  ) {
+    return 'some';
+  } else {
+    return 'none';
+  }
+}
diff --git a/src/features/canvassAssignments/utils/getVisitState.spec.ts b/src/features/canvassAssignments/utils/getVisitState.spec.ts
new file mode 100644
index 000000000..f30341ff9
--- /dev/null
+++ b/src/features/canvassAssignments/utils/getVisitState.spec.ts
@@ -0,0 +1,80 @@
+import getVisitState from './getVisitState';
+
+describe('getVisitState()', () => {
+  it('returns "none" when passed an empty array', () => {
+    const state = getVisitState([], '123');
+
+    expect(state).toEqual('none');
+  });
+
+  it('returns "none" when passed an array where no housholds have visits in current assignment', () => {
+    const state = getVisitState(
+      [
+        { id: '1', title: 'Door 1', visits: [] },
+        {
+          id: '2',
+          title: 'Door 2',
+          visits: [
+            {
+              canvassAssId: '345',
+              id: 'a',
+              noteToOfficial: '',
+              responses: [],
+              timestamp: '20230503',
+            },
+          ],
+        },
+      ],
+      '123'
+    );
+
+    expect(state).toEqual('none');
+  });
+
+  it('returns "some" when passed an array where only one household has visits in the current assignment', () => {
+    const state = getVisitState(
+      [
+        { id: '1', title: 'Door 1', visits: [] },
+        {
+          id: '2',
+          title: 'Door 2',
+          visits: [
+            {
+              canvassAssId: '123',
+              id: 'a',
+              noteToOfficial: '',
+              responses: [],
+              timestamp: '20230503',
+            },
+          ],
+        },
+      ],
+      '123'
+    );
+
+    expect(state).toEqual('some');
+  });
+
+  it('returns "all" when passed an array where all households have visits in the current assignment', () => {
+    const state = getVisitState(
+      [
+        {
+          id: '2',
+          title: 'Door 2',
+          visits: [
+            {
+              canvassAssId: '123',
+              id: 'a',
+              noteToOfficial: '',
+              responses: [],
+              timestamp: '20230503',
+            },
+          ],
+        },
+      ],
+      '123'
+    );
+
+    expect(state).toEqual('all');
+  });
+});
diff --git a/src/features/canvassAssignments/utils/getVisitState.ts b/src/features/canvassAssignments/utils/getVisitState.ts
new file mode 100644
index 000000000..2356261de
--- /dev/null
+++ b/src/features/canvassAssignments/utils/getVisitState.ts
@@ -0,0 +1,33 @@
+import { Household } from '../types';
+
+export type ProgressState = 'none' | 'some' | 'all';
+
+export default function getVisitState(
+  households: Household[],
+  canvassAssId: string | null
+): ProgressState {
+  let numberOfVisitedHouseholds = 0;
+  households.forEach((household) => {
+    const hasVisitsInCurrentAssignment = household.visits.some((visit) => {
+      return visit.canvassAssId == canvassAssId;
+    });
+
+    if (hasVisitsInCurrentAssignment) {
+      numberOfVisitedHouseholds++;
+    }
+  });
+
+  if (
+    numberOfVisitedHouseholds > 0 &&
+    numberOfVisitedHouseholds == households.length
+  ) {
+    return 'all';
+  } else if (
+    numberOfVisitedHouseholds > 0 &&
+    numberOfVisitedHouseholds < households.length
+  ) {
+    return 'some';
+  } else {
+    return 'none';
+  }
+}
diff --git a/src/features/canvassAssignments/utils/isWithinLast24Hours.tsx b/src/features/canvassAssignments/utils/isWithinLast24Hours.tsx
deleted file mode 100644
index 02195e6aa..000000000
--- a/src/features/canvassAssignments/utils/isWithinLast24Hours.tsx
+++ /dev/null
@@ -1,18 +0,0 @@
-export const isWithinLast24Hours = (timestamps: string[]): boolean => {
-  if (timestamps.length === 0) {
-    return false;
-  }
-  const now = Date.now();
-  const twentyFourHoursInMillis = 24 * 60 * 60 * 1000;
-  const twentyFourHoursAgo = now - twentyFourHoursInMillis;
-
-  return timestamps.some((timestamp) => {
-    const parsedTimestamp = Date.parse(timestamp);
-
-    if (isNaN(parsedTimestamp)) {
-      return false;
-    }
-
-    return parsedTimestamp >= twentyFourHoursAgo && parsedTimestamp <= now;
-  });
-};
diff --git a/src/features/canvassAssignments/utils/markerIcon.tsx b/src/features/canvassAssignments/utils/markerIcon.tsx
deleted file mode 100644
index 639465d2a..000000000
--- a/src/features/canvassAssignments/utils/markerIcon.tsx
+++ /dev/null
@@ -1,24 +0,0 @@
-interface MarkerIconProps {
-  selected: boolean;
-}
-
-const MarkerIcon: React.FC<MarkerIconProps> = ({ selected }) => (
-  <svg fill="none" height="35" viewBox="0 0 30 40" width="25">
-    <path
-      d="M14 38.479C13.6358 38.0533 13.1535 37.4795
-        12.589 36.7839C11.2893 35.1826 9.55816 32.9411
-        7.82896 30.3782C6.09785 27.8124 4.38106 24.9426
-        3.1001 22.0833C1.81327 19.211 1 16.4227 1 14C1
-        6.81228 6.81228 1 14 1C21.1877 1 27 6.81228 27 14C27
-        16.4227 26.1867 19.211 24.8999 22.0833C23.6189 24.9426
-        21.9022 27.8124 20.171 30.3782C18.4418 32.9411 16.7107
-        35.1826 15.411 36.7839C14.8465 37.4795 14.3642
-        38.0533 14 38.479Z"
-      fill={selected ? '#ED1C55' : 'white'}
-      stroke={'#ED1C55'}
-      strokeWidth="2"
-    />
-  </svg>
-);
-
-export default MarkerIcon;
diff --git a/src/utils/testing/mocks/mockState.ts b/src/utils/testing/mocks/mockState.ts
index 2fb3840b1..611f45eff 100644
--- a/src/utils/testing/mocks/mockState.ts
+++ b/src/utils/testing/mocks/mockState.ts
@@ -25,7 +25,7 @@ export default function mockState(overrides?: RootState) {
     canvassAssignments: {
       assigneesByCanvassAssignmentId: {},
       canvassAssignmentList: remoteList(),
-      mySessionsList: remoteList(),
+      myAssignmentsWithAreasList: remoteList(),
       placeList: remoteList(),
       sessionsByAssignmentId: {},
       statsByCanvassAssId: {},