Here's how job card sorting works by plan:

1. Plan → Tier mapping (on job creation)

When a job is created from a paid plan (POK or Pay Later), the pricing plan sets the job tier:

Plan Slug	Job Tier	Duration
payg_standard	standard	30 days public
payg_boost	boost	7 days priority
payg_featured	featured	30 days priority

Relevant code in jobs-service.ts:

jobs-service.ts

Lines 1116-1134

        if (invoiceWithPlan?.pricingPlan) {

          const plan = invoiceWithPlan.pricingPlan

          const planSlug = plan.slug

          if (planSlug === 'payg_featured') {

            tier = 'featured'

            // Featured gets priority placement (default 30 days)

            const days = plan.priorityDays || 30

            featuredUntil = new Date()

            featuredUntil.setDate(featuredUntil.getDate() + days)

            priorityUntil = featuredUntil

          } else if (planSlug === 'payg_boost') {

            tier = 'boost'

            // Boost gets priority placement (default 7 days)

            const days = plan.priorityDays || 7

            priorityUntil = new Date()

            priorityUntil.setDate(priorityUntil.getDate() + days)

          }

        }

2. Job card sort order (by plan/tier)

Jobs are ordered by tier priority, then by freshness. Logic is in JobsService.getJobs (and similarly in getInternships, getPublishedJobs, etc.):

jobs-service.ts

Lines 366-391

    // Sort jobs by plan/tier: Featured (active) > Sponsored (active) > Boost (active) > Standard

    const now = new Date()

    const sortedJobs = jobsWithDetails.sort((a, b) => {

      const getTierPriority = (job: any): number => {

        const tier = job.tier ?? 'standard'

        const priorityUntil = job.priorityUntil ? new Date(job.priorityUntil) : null

        const sponsoredUntil = job.sponsoredUntil ? new Date(job.sponsoredUntil) : null

        const priorityActive = !!priorityUntil && priorityUntil > now

        const sponsoredActive = !!(job.sponsoredLevel && sponsoredUntil && sponsoredUntil > now)

        if (tier === 'featured' && priorityActive) return 0

        if (sponsoredActive) return 1

        if (tier === 'boost') return 2 // Boost always above standard (active or expired)

        return 3

      }

      const diff = getTierPriority(a) - getTierPriority(b)

      if (diff !== 0) return diff

      // Same tier: newest refreshed first, then newest created

      const refreshedA = a.refreshedAt ? new Date(a.refreshedAt).getTime() : 0

      const refreshedB = b.refreshedAt ? new Date(b.refreshedAt).getTime() : 0

      if (refreshedA !== refreshedB) return refreshedB - refreshedA

      return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()

    })

3. Priority rules (summary)

Order	Condition	Plan / source
0 (first)	Featured tier and priorityUntil > now	payg_featured
1	Active sponsorship (has level + sponsoredUntil > now)	Sponsorship addon (addon_sponsored)
2	Boost tier (active or expired)	payg_boost
3 (last)	All others	payg_standard or jobs without a paid tier

Within the same tier: jobs are ordered by refreshedAt DESC, then createdAt DESC.

4. Fields that drive sorting

• tier – standard \| boost \| featured (from plan at creation)

• priorityUntil – end of featured/boost priority period

• sponsoredLevel and sponsoredUntil – sponsorship status

• refreshedAt – last refresh for secondary sort

• createdAt – fallback for secondary sort

5. Where it happens

Sorting is done in the backend in:

• JobsService.getJobs() – main job listings

• JobsService.getInternships() – internships

• JobsService.getPublishedJobs() – published jobs

The homepage uses the order from JobsService.getJobs() and does not re-sort. Internships use a separate sort that prioritizes sponsoredLevel instead of tier.