diff --git a/app/controllers/api/v1/market_applications_controller.rb b/app/controllers/api/v1/market_applications_controller.rb
index 5f2369adc..9bfa5f285 100644
--- a/app/controllers/api/v1/market_applications_controller.rb
+++ b/app/controllers/api/v1/market_applications_controller.rb
@@ -75,11 +75,8 @@ def success_response(market_application)
   end
 
   def application_url_for(market_application)
-    if market_application.application_mode_choice_required?
-      return Rails.application.routes.url_helpers.application_mode_candidate_market_application_url(
-        market_application.identifier
-      )
-    end
+    target, step = market_application.next_required_wizard_step
+    return wizard_step_url(target, step) if target
 
     Rails.application.routes.url_helpers.step_candidate_market_application_url(
       market_application.identifier,
@@ -87,6 +84,15 @@ def application_url_for(market_application)
     )
   end
 
+  def wizard_step_url(market_application, step)
+    case step
+    when :application_mode
+      Rails.application.routes.url_helpers.application_mode_candidate_market_application_url(market_application.identifier)
+    when :grouping_legal_type
+      Rails.application.routes.url_helpers.grouping_legal_type_candidate_market_application_url(market_application.identifier)
+    end
+  end
+
   def validate_application_completed
     return if @market_application.completed?
 
diff --git a/app/controllers/candidate/application_modes_controller.rb b/app/controllers/candidate/application_modes_controller.rb
index f5322d010..d7858a7ed 100644
--- a/app/controllers/candidate/application_modes_controller.rb
+++ b/app/controllers/candidate/application_modes_controller.rb
@@ -4,14 +4,15 @@ module Candidate
   class ApplicationModesController < Candidate::ApplicationController
     include Candidate::GroupementFeatureGuard
     include Candidate::MarketApplicationGuard
+    include Candidate::WizardRoutable
 
     prepend_before_action :find_market_application
     before_action :redirect_if_mode_already_chosen
 
     def show
-      @already_mandataire = already_mandataire_elsewhere?
-      @readonly = @market_application.application_mode.present?
-      @readonly_continue_path = next_step_path(@market_application) if @readonly
+      @already_mandataire = presenter.already_mandataire?
+      @readonly = presenter.readonly?
+      @readonly_continue_path = next_required_wizard_step_path(@market_application) if @readonly
     end
 
     def update
@@ -22,7 +23,7 @@ def update
 
       return handle_success(result) if result.success?
 
-      @already_mandataire = already_mandataire_elsewhere?
+      @already_mandataire = presenter.already_mandataire?
       @errors = result.errors
       render :show, status: :unprocessable_content
     end
@@ -39,27 +40,15 @@ def redirect_if_mode_already_chosen
       return if @market_application.application_mode.nil?
       return if action_name == 'show' && params[:readonly].present?
 
-      redirect_to next_step_path(@market_application)
+      redirect_to next_required_wizard_step_path(@market_application)
     end
 
-    def next_step_path(market_application)
-      if market_application.grouping_legal_type_choice_required?
-        grouping_legal_type_candidate_market_application_path(market_application.identifier)
-      else
-        company_identification_candidate_market_application_path(market_application.identifier)
-      end
-    end
-
-    def already_mandataire_elsewhere?
-      Grouping
-        .joins(:mandataire_market_application)
-        .where(public_market: @market_application.public_market, market_applications: { siret: @market_application.siret })
-        .where.not(market_applications: { id: @market_application.id })
-        .exists?
+    def presenter
+      @presenter ||= Candidate::ApplicationModePresenter.new(@market_application)
     end
 
     def handle_success(result)
-      redirect_to next_step_path(result.market_application)
+      redirect_to next_required_wizard_step_path(result.market_application)
     end
   end
 end
diff --git a/app/controllers/candidate/grouping_legal_types_controller.rb b/app/controllers/candidate/grouping_legal_types_controller.rb
index 03da97a33..7e4bccc24 100644
--- a/app/controllers/candidate/grouping_legal_types_controller.rb
+++ b/app/controllers/candidate/grouping_legal_types_controller.rb
@@ -8,7 +8,9 @@ class GroupingLegalTypesController < Candidate::ApplicationController
     prepend_before_action :find_market_application
     before_action :redirect_unless_mandataire
 
-    def show; end
+    def show
+      @grouping = presenter.grouping
+    end
 
     def update
       result = Candidate::SetGroupingLegalType.call(
@@ -18,6 +20,7 @@ def update
 
       return handle_success if result.success?
 
+      @grouping = presenter.grouping
       @errors = result.errors
       render :show, status: :unprocessable_content
     end
@@ -31,12 +34,15 @@ def find_market_application
     end
 
     def redirect_unless_mandataire
-      @grouping = Grouping.joins(:mandataire_market_application).find_by(market_applications: { id: @market_application.id })
-      return if @grouping
+      return if presenter.grouping
 
       redirect_to application_mode_candidate_market_application_path(@market_application.identifier)
     end
 
+    def presenter
+      @presenter ||= Candidate::GroupingLegalTypePresenter.new(@market_application)
+    end
+
     def handle_success
       redirect_to company_identification_candidate_market_application_path(@market_application.identifier)
     end
diff --git a/app/controllers/candidate/sessions_controller.rb b/app/controllers/candidate/sessions_controller.rb
index cd84b3b17..c93c25713 100644
--- a/app/controllers/candidate/sessions_controller.rb
+++ b/app/controllers/candidate/sessions_controller.rb
@@ -2,6 +2,8 @@
 
 module Candidate
   class SessionsController < Candidate::ApplicationController
+    include Candidate::WizardRoutable
+
     skip_before_action :require_candidate_authentication
 
     def new
@@ -38,23 +40,28 @@ def destroy
 
     def sign_in_candidate(user, market_application)
       reconnection = market_application.user_id.present?
-      market_application.update!(user:) unless reconnection
+      link_candidate_to_application(user, market_application) unless reconnection
       session[:user_id] = user.id
       session[:market_application_identifier] = market_application.identifier
       redirect_to first_step_path(market_application)
     end
 
+    def link_candidate_to_application(user, market_application)
+      counterpart = market_application.groupement_counterpart || market_application.solo_counterpart
+      market_application.update!(user:)
+      counterpart&.update!(user:)
+    end
+
     def first_step_path(market_application)
-      if market_application.completed?
-        return deadline_passed_candidate_market_application_path(market_application.identifier) unless market_application.public_market.open?
+      return completed_application_path(market_application) if market_application.completed?
 
-        return candidate_sync_status_path(market_application.identifier)
-      end
+      next_required_wizard_step_path(market_application)
+    end
 
-      return application_mode_candidate_market_application_path(market_application.identifier) if market_application.application_mode_choice_required?
-      return grouping_legal_type_candidate_market_application_path(market_application.identifier) if market_application.grouping_legal_type_choice_required?
+    def completed_application_path(market_application)
+      return deadline_passed_candidate_market_application_path(market_application.identifier) unless market_application.public_market.open?
 
-      company_identification_candidate_market_application_path(market_application.identifier)
+      candidate_sync_status_path(market_application.identifier)
     end
 
     def handle_magic_link_sent(result)
diff --git a/app/controllers/concerns/candidate/application_mode_guard.rb b/app/controllers/concerns/candidate/application_mode_guard.rb
index 848431f76..d48198590 100644
--- a/app/controllers/concerns/candidate/application_mode_guard.rb
+++ b/app/controllers/concerns/candidate/application_mode_guard.rb
@@ -3,6 +3,7 @@
 module Candidate
   module ApplicationModeGuard
     extend ActiveSupport::Concern
+    include Candidate::WizardRoutable
 
     included do
       before_action :redirect_to_application_mode_choice
@@ -11,9 +12,9 @@ module ApplicationModeGuard
     private
 
     def redirect_to_application_mode_choice
-      return unless @market_application&.application_mode_choice_required?
+      return unless @market_application
 
-      redirect_to application_mode_candidate_market_application_path(@market_application.identifier)
+      redirect_to next_required_wizard_step_path(@market_application) if @market_application.next_required_wizard_step
     end
   end
 end
diff --git a/app/controllers/concerns/candidate/wizard_routable.rb b/app/controllers/concerns/candidate/wizard_routable.rb
new file mode 100644
index 000000000..d1e750e7a
--- /dev/null
+++ b/app/controllers/concerns/candidate/wizard_routable.rb
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Candidate
+  module WizardRoutable
+    extend ActiveSupport::Concern
+
+    private
+
+    def wizard_step_path(market_application, step)
+      case step
+      when :application_mode
+        application_mode_candidate_market_application_path(market_application.identifier)
+      when :grouping_legal_type
+        grouping_legal_type_candidate_market_application_path(market_application.identifier)
+      end
+    end
+
+    def next_required_wizard_step_path(market_application)
+      target, step = market_application.next_required_wizard_step
+      return company_identification_candidate_market_application_path(market_application.identifier) unless target
+
+      wizard_step_path(target, step)
+    end
+  end
+end
diff --git a/app/models/market_application.rb b/app/models/market_application.rb
index 36ee72eaf..6e29312d2 100644
--- a/app/models/market_application.rb
+++ b/app/models/market_application.rb
@@ -53,10 +53,34 @@ def application_mode_choice_required?
   end
 
   def grouping_legal_type_choice_required?
+    return false if completed?
+
     FeatureFlags::Groupement.enabled? && groupement? &&
       Grouping.joins(:mandataire_market_application).exists?(legal_type: nil, market_applications: { id: })
   end
 
+  def groupement_counterpart
+    return nil if groupement?
+
+    MarketApplication.where(public_market:, siret:, application_mode: :groupement, user_id:).where.not(id:).first
+  end
+
+  def solo_counterpart
+    return nil if solo?
+
+    MarketApplication.where(public_market:, siret:, application_mode: :solo, user_id:).where.not(id:).first
+  end
+
+  def next_required_wizard_step
+    return nil unless FeatureFlags::Groupement.enabled?
+    return [self, :application_mode] if application_mode_choice_required?
+
+    target = groupement_counterpart || self
+    return [target, :grouping_legal_type] if target.grouping_legal_type_choice_required?
+
+    nil
+  end
+
   def update_api_status(api_name, status:, fields_filled: 0)
     with_lock do
       updated_status = (api_fetch_status || {}).dup
diff --git a/app/presenters/candidate/application_mode_presenter.rb b/app/presenters/candidate/application_mode_presenter.rb
new file mode 100644
index 000000000..6812621f4
--- /dev/null
+++ b/app/presenters/candidate/application_mode_presenter.rb
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Candidate
+  class ApplicationModePresenter
+    def initialize(market_application)
+      @market_application = market_application
+    end
+
+    def already_mandataire?
+      Grouping
+        .joins(:mandataire_market_application)
+        .where(public_market: market_application.public_market, market_applications: { siret: market_application.siret })
+        .where.not(market_applications: { id: market_application.id })
+        .exists?
+    end
+
+    def readonly?
+      market_application.application_mode.present?
+    end
+
+    private
+
+    attr_reader :market_application
+  end
+end
diff --git a/app/presenters/candidate/grouping_legal_type_presenter.rb b/app/presenters/candidate/grouping_legal_type_presenter.rb
new file mode 100644
index 000000000..549239d21
--- /dev/null
+++ b/app/presenters/candidate/grouping_legal_type_presenter.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Candidate
+  class GroupingLegalTypePresenter
+    def initialize(market_application)
+      @market_application = market_application
+    end
+
+    def grouping
+      return @grouping if defined?(@grouping)
+
+      @grouping = Grouping.joins(:mandataire_market_application)
+        .find_by(market_applications: { id: market_application.id })
+    end
+
+    private
+
+    attr_reader :market_application
+  end
+end
diff --git a/app/views/candidate/grouping_legal_types/show.html.erb b/app/views/candidate/grouping_legal_types/show.html.erb
index 632a4385d..429402a60 100644
--- a/app/views/candidate/grouping_legal_types/show.html.erb
+++ b/app/views/candidate/grouping_legal_types/show.html.erb
@@ -2,7 +2,7 @@
 
 <div class="fr-container fr-py-6w">
   <p class="fr-text--sm fr-mb-1w"><%= t('candidate.grouping_legal_types.step_current') %></p>
-  <h1 class="fr-h3 fr-mb-2w"><%= t('candidate.grouping_legal_types.title') %></h1>
+  <h1 class="fr-h4 fr-mb-2w"><%= t('candidate.grouping_legal_types.title') %></h1>
 
   <div class="grouping-legal-type-stepper fr-mb-2w">
     <div class="grouping-legal-type-stepper__step grouping-legal-type-stepper__step--done"></div>
@@ -15,7 +15,7 @@
     <%= t('candidate.grouping_legal_types.step_next_label') %>
   </p>
 
-  <h2 class="fr-h4 fr-mb-3w"><%= t('candidate.grouping_legal_types.question') %></h2>
+  <h2 class="fr-h1 fr-mb-1w"><%= t('candidate.grouping_legal_types.question') %></h2>
 
   <% if @errors.present? %>
     <div class="fr-alert fr-alert--error fr-mb-3w" role="alert">
@@ -34,9 +34,7 @@
     <p><%= t('candidate.grouping_legal_types.alert') %></p>
   </div>
 
-  <%= form_with url: grouping_legal_type_candidate_market_application_path(@market_application.identifier),
-                method: :patch,
-                data: { controller: "enable-on-choice" } do |form| %>
+  <%= form_with url: grouping_legal_type_candidate_market_application_path(@market_application.identifier), method: :patch, data: { controller: "enable-on-choice" } do |form| %>
     <fieldset class="fr-fieldset">
       <legend class="fr-fieldset__legend fr-sr-only"><%= t('candidate.grouping_legal_types.question') %></legend>
 
@@ -57,7 +55,7 @@
                   <span class="application-mode-choice__title">
                     <%= t("candidate.grouping_legal_types.#{legal_type}.label") %>
                     <% if legal_type == 'conjoint_mandataire_solidaire' %>
-                      <span class="fr-badge fr-badge--info fr-badge--sm">
+                      <span class="fr-badge fr-badge--info fr-badge--no-icon fr-badge--sm">
                         <%= t('candidate.grouping_legal_types.most_common_badge') %>
                       </span>
                     <% end %>
diff --git a/features/candidacy_mode_choice.feature b/features/candidacy_mode_choice.feature
index fac695dbe..67cb0197d 100644
--- a/features/candidacy_mode_choice.feature
+++ b/features/candidacy_mode_choice.feature
@@ -45,6 +45,15 @@ Feature: Candidate chooses their candidacy mode
     And my application mode should be "solo"
     And a second market application should exist with mode "groupement"
 
+  @javascript
+  Scenario: Candidate reconnects from the groupement funnel after choosing mixte
+    When I visit the magic link
+    And I choose the candidacy mode "mixte"
+    Then I should land on the grouping legal type step of the groupement application
+    When I request a new magic link for the groupement application
+    And I click the link from the latest email
+    Then I should land on the grouping legal type step of the groupement application
+
   Scenario: The choice screen is never shown again once a mode is chosen
     Given the candidate application already has the mode "solo"
     When I visit the magic link
diff --git a/features/step_definitions/candidate_authentication_steps.rb b/features/step_definitions/candidate_authentication_steps.rb
index 4f19f21b5..51ef62db2 100644
--- a/features/step_definitions/candidate_authentication_steps.rb
+++ b/features/step_definitions/candidate_authentication_steps.rb
@@ -47,6 +47,19 @@
   )
 end
 
+When('I request a new magic link for the groupement application') do
+  visit new_candidate_sessions_path(market_application_id: @groupement_market_application.identifier)
+  fill_in I18n.t('candidate.sessions.new.email_label'), with: @user.email
+  find_button(I18n.t('candidate.sessions.new.submit'), disabled: false).click
+  expect(page).to have_current_path(sent_candidate_sessions_path, ignore_query: true)
+end
+
+When('I click the link from the latest email') do
+  mail = ActionMailer::Base.deliveries.last
+  url = mail.text_part.body.decoded[%r{https?://\S+}]
+  visit URI(url).request_uri
+end
+
 Then('I should see the authentication form') do
   expect(page).to have_selector('form[action*="candidate/sessions"]')
 end
diff --git a/spec/interactors/candidate/create_applications_for_mode_spec.rb b/spec/interactors/candidate/create_applications_for_mode_spec.rb
index 3dbcb0aa0..c23927d53 100644
--- a/spec/interactors/candidate/create_applications_for_mode_spec.rb
+++ b/spec/interactors/candidate/create_applications_for_mode_spec.rb
@@ -103,6 +103,16 @@
         expect(Grouping.count).to eq(1)
         expect(Grouping.last.mandataire_market_application).to eq(result.market_application)
       end
+
+      context 'when the candidate is already authenticated on the solo application' do
+        let(:user) { create(:user) }
+        let!(:market_application) { create(:market_application, public_market:, siret:, user:) }
+
+        it 'links the groupement counterpart to the same user' do
+          result = subject
+          expect(result.market_application.user).to eq(user)
+        end
+      end
     end
 
     context 'when mixte mode finds an existing groupement application owned by another user' do
diff --git a/spec/models/market_application_spec.rb b/spec/models/market_application_spec.rb
index 04697da44..3dc827fc9 100644
--- a/spec/models/market_application_spec.rb
+++ b/spec/models/market_application_spec.rb
@@ -204,6 +204,79 @@
 
       expect(application.grouping_legal_type_choice_required?).to be false
     end
+
+    it 'returns false when the application is already completed, even without a legal_type' do
+      allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
+      application = create(:market_application, :completed, public_market:, application_mode: :groupement)
+      create(:grouping, public_market:, mandataire_market_application: application, legal_type: nil)
+
+      expect(application.grouping_legal_type_choice_required?).to be false
+    end
+  end
+
+  describe '#groupement_counterpart' do
+    let(:siret) { '73282932000074' }
+
+    it 'finds the groupement application for the same SIRET and market when called on the solo one' do
+      solo = create(:market_application, public_market:, siret:, application_mode: :solo)
+      groupement = create(:market_application, public_market:, siret:, application_mode: :groupement)
+
+      expect(solo.groupement_counterpart).to eq(groupement)
+    end
+
+    it 'returns nil when the application is not mixte-related (only a solo exists)' do
+      solo = create(:market_application, public_market:, siret:, application_mode: :solo)
+
+      expect(solo.groupement_counterpart).to be_nil
+    end
+
+    it 'returns nil when the application itself is the groupement one' do
+      groupement = create(:market_application, public_market:, siret:, application_mode: :groupement)
+
+      expect(groupement.groupement_counterpart).to be_nil
+    end
+
+    it 'returns nil for a solo application that is not part of a mixte pair on another market' do
+      other_market = create(:public_market, :completed, editor:)
+      create(:market_application, public_market: other_market, siret:, application_mode: :groupement)
+      solo = create(:market_application, public_market:, siret:, application_mode: :solo)
+
+      expect(solo.groupement_counterpart).to be_nil
+    end
+  end
+
+  describe '#next_required_wizard_step' do
+    it 'does not query for a groupement_counterpart when the feature flag is disabled' do
+      allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(false)
+      application = create(:market_application, public_market:, application_mode: :solo)
+
+      expect(application).not_to receive(:groupement_counterpart)
+      expect(application.next_required_wizard_step).to be_nil
+    end
+
+    it 'returns application_mode when the mode has not been chosen yet' do
+      allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
+      application = build(:market_application, public_market:, application_mode: nil)
+
+      expect(application.next_required_wizard_step).to eq([application, :application_mode])
+    end
+
+    it 'returns grouping_legal_type on the groupement counterpart for a mixte solo application' do
+      allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
+      siret = '73282932000074'
+      solo = create(:market_application, public_market:, siret:, application_mode: :solo)
+      groupement = create(:market_application, public_market:, siret:, application_mode: :groupement)
+      create(:grouping, public_market:, mandataire_market_application: groupement, legal_type: nil)
+
+      expect(solo.next_required_wizard_step).to eq([groupement, :grouping_legal_type])
+    end
+
+    it 'returns nil once nothing is required' do
+      allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
+      application = create(:market_application, public_market:, application_mode: :solo)
+
+      expect(application.next_required_wizard_step).to be_nil
+    end
   end
 
   describe '#in_progress?' do
diff --git a/spec/presenters/candidate/application_mode_presenter_spec.rb b/spec/presenters/candidate/application_mode_presenter_spec.rb
new file mode 100644
index 000000000..532ccf48f
--- /dev/null
+++ b/spec/presenters/candidate/application_mode_presenter_spec.rb
@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Candidate::ApplicationModePresenter, type: :presenter do
+  let(:editor) { create(:editor) }
+  let(:public_market) { create(:public_market, :completed, editor:) }
+  let(:siret) { '73282932000074' }
+
+  before { allow(SiretValidator).to receive(:valid?).and_return(true) }
+
+  describe '#already_mandataire?' do
+    it 'returns true when another application for the same SIRET and market is mandataire of a grouping' do
+      mandataire_application = create(:market_application, public_market:, siret:, application_mode: :groupement)
+      create(:grouping, public_market:, mandataire_market_application: mandataire_application)
+      application = create(:market_application, public_market:, siret:, application_mode: :solo)
+
+      presenter = described_class.new(application)
+
+      expect(presenter.already_mandataire?).to be true
+    end
+
+    it 'returns false when no other application is mandataire' do
+      application = create(:market_application, public_market:, siret:, application_mode: :solo)
+
+      presenter = described_class.new(application)
+
+      expect(presenter.already_mandataire?).to be false
+    end
+  end
+
+  describe '#readonly?' do
+    it 'returns true when the application already has a mode' do
+      application = create(:market_application, public_market:, siret:, application_mode: :solo)
+
+      expect(described_class.new(application).readonly?).to be true
+    end
+
+    it 'returns false when no mode has been chosen yet' do
+      application = build(:market_application, public_market:, siret:, application_mode: nil)
+
+      expect(described_class.new(application).readonly?).to be false
+    end
+  end
+end
diff --git a/spec/presenters/candidate/grouping_legal_type_presenter_spec.rb b/spec/presenters/candidate/grouping_legal_type_presenter_spec.rb
new file mode 100644
index 000000000..fdb650848
--- /dev/null
+++ b/spec/presenters/candidate/grouping_legal_type_presenter_spec.rb
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Candidate::GroupingLegalTypePresenter, type: :presenter do
+  let(:editor) { create(:editor) }
+  let(:public_market) { create(:public_market, :completed, editor:) }
+
+  before { allow(SiretValidator).to receive(:valid?).and_return(true) }
+
+  describe '#grouping' do
+    it 'finds the grouping for which the application is mandataire' do
+      application = create(:market_application, public_market:, application_mode: :groupement)
+      grouping = create(:grouping, public_market:, mandataire_market_application: application)
+
+      expect(described_class.new(application).grouping).to eq(grouping)
+    end
+
+    it 'returns nil when the application is not mandataire of any grouping' do
+      application = create(:market_application, public_market:, application_mode: :solo)
+
+      expect(described_class.new(application).grouping).to be_nil
+    end
+  end
+end
diff --git a/spec/requests/api/v1/market_applications_spec.rb b/spec/requests/api/v1/market_applications_spec.rb
index b0a93bc78..7cfa4ceb7 100644
--- a/spec/requests/api/v1/market_applications_spec.rb
+++ b/spec/requests/api/v1/market_applications_spec.rb
@@ -7,6 +7,8 @@
   let(:public_market) { create(:public_market, :published, editor:) }
   let(:access_token) { oauth_access_token_for(editor) }
 
+  before { allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(false) }
+
   describe 'POST /api/v1/public_markets/:public_market_id/market_applications' do
     let(:valid_siret) { '73282932000074' }
     let(:invalid_siret) { '12345678901234' }
@@ -111,6 +113,23 @@
       expect(json_response['application_url']).to include('/company_identification')
     end
 
+    it 'points to the groupement counterpart grouping_legal_type step when the existing application is mixte' do
+      allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
+      solo_application = create(:market_application, public_market:, siret: valid_siret, application_mode: :solo)
+      groupement_application = create(:market_application, public_market:, siret: valid_siret, application_mode: :groupement)
+      create(:grouping, public_market:, mandataire_market_application: groupement_application, legal_type: nil)
+
+      post "/api/v1/public_markets/#{public_market.identifier}/market_applications",
+        params: valid_params,
+        headers: { 'Authorization' => "Bearer #{access_token}" },
+        as: :json
+
+      expect(response).to have_http_status(:ok)
+      json_response = response.parsed_body
+      expect(json_response['identifier']).to eq(solo_application.identifier)
+      expect(json_response['application_url']).to include("/#{groupement_application.identifier}/grouping_legal_type")
+    end
+
     it 'returns error when public market not found' do
       post '/api/v1/public_markets/NONEXISTENT/market_applications',
         params: valid_params,
diff --git a/spec/requests/candidate/application_modes_spec.rb b/spec/requests/candidate/application_modes_spec.rb
index c703f90cc..fad9e6973 100644
--- a/spec/requests/candidate/application_modes_spec.rb
+++ b/spec/requests/candidate/application_modes_spec.rb
@@ -14,11 +14,20 @@
     sign_in_as_candidate(user, market_application)
   end
 
+  def wizard_step_path(market_application, step)
+    case step
+    when :application_mode
+      application_mode_candidate_market_application_path(market_application.identifier)
+    when :grouping_legal_type
+      grouping_legal_type_candidate_market_application_path(market_application.identifier)
+    end
+  end
+
   describe 'authentication' do
     it 'renders the login form instead of the page when not authenticated' do
       other_application = create(:market_application, public_market:, siret: '11122233300014')
 
-      get application_mode_candidate_market_application_path(other_application.identifier)
+      get wizard_step_path(other_application, :application_mode)
 
       expect(response).to have_http_status(:ok)
       expect(response.body).to include(I18n.t('candidate.sessions.new.title'))
@@ -26,231 +35,271 @@
     end
   end
 
-  describe 'GET /candidate/market_applications/:identifier/application_mode' do
+  describe 'GET .../application_mode' do
     it 'renders successfully when the mode is not chosen yet' do
-      get application_mode_candidate_market_application_path(market_application.identifier)
+      get wizard_step_path(market_application, :application_mode)
       expect(response).to have_http_status(:ok)
     end
 
     it 'returns 404 when the feature flag is disabled' do
       allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(false)
 
-      get application_mode_candidate_market_application_path(market_application.identifier)
+      get wizard_step_path(market_application, :application_mode)
       expect(response).to have_http_status(:not_found)
     end
 
-    it 'redirects to company_identification when the mode is already chosen' do
+    it 'redirects to company_identification when the mode is already chosen and readonly is not requested' do
       market_application.update!(application_mode: :solo)
 
-      get application_mode_candidate_market_application_path(market_application.identifier)
+      get wizard_step_path(market_application, :application_mode)
+      expect(response).to redirect_to(
+        company_identification_candidate_market_application_path(market_application.identifier)
+      )
+    end
+
+    context 'when the application is already completed' do
+      let(:market_application) do
+        create(:market_application, :completed, public_market:, siret: '73282932000074')
+      end
+
+      it 'redirects to sync status instead of showing the choice screen' do
+        get wizard_step_path(market_application, :application_mode)
+
+        expect(response).to redirect_to(candidate_sync_status_path(market_application.identifier))
+      end
+    end
+  end
+
+  describe 'PATCH .../application_mode' do
+    it 'sets the mode to solo and redirects to company_identification' do
+      patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'solo' }
+
+      expect(market_application.reload).to be_solo
       expect(response).to redirect_to(
         company_identification_candidate_market_application_path(market_application.identifier)
       )
     end
 
-    context 'when the mode is groupement and the legal type is not chosen yet' do
+    it 'creates a grouping when choosing groupement and redirects to grouping_legal_type' do
+      expect do
+        patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'groupement' }
+      end.to change(Grouping, :count).by(1)
+
+      expect(market_application.reload).to be_groupement
+      expect(response).to redirect_to(wizard_step_path(market_application, :grouping_legal_type))
+    end
+
+    it 'creates two applications when choosing mixte and redirects to grouping_legal_type of the groupement counterpart' do
+      expect do
+        patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'mixte' }
+      end.to change(MarketApplication, :count).by(1)
+
+      groupement_application = MarketApplication.find_by(public_market:, siret: market_application.siret,
+        application_mode: :groupement)
+      expect(response).to redirect_to(wizard_step_path(groupement_application, :grouping_legal_type))
+    end
+
+    it 'does not require re-authentication when reaching the next step after choosing groupement' do
+      patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'groupement' }
+
+      get wizard_step_path(market_application, :grouping_legal_type)
+
+      expect(response).to have_http_status(:ok)
+      expect(response.body).not_to include(I18n.t('candidate.sessions.new.siret_label'))
+    end
+
+    it 'associates the authenticated user to the groupement counterpart created in mixte mode' do
+      patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'mixte' }
+
+      groupement_application = MarketApplication.where(public_market:, siret: market_application.siret,
+        application_mode: :groupement).sole
+
+      expect(groupement_application.user).to eq(user)
+    end
+
+    it 'does not require re-authentication when reaching the next step after choosing mixte' do
+      patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'mixte' }
+
+      groupement_application = MarketApplication.where(public_market:, siret: market_application.siret,
+        application_mode: :groupement).sole
+
+      get wizard_step_path(groupement_application, :grouping_legal_type)
+
+      expect(response).to have_http_status(:ok)
+      expect(response.body).not_to include(I18n.t('candidate.sessions.new.siret_label'))
+    end
+
+    context 'when the SIRET is already mandataire of a grouping on this market' do
       before do
-        market_application.update!(application_mode: :groupement)
-        create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: nil)
+        other_application = create(:market_application, public_market:, siret: market_application.siret,
+          application_mode: :groupement)
+        create(:grouping, public_market:, mandataire_market_application: other_application)
       end
 
-      it 'redirects to grouping_legal_type instead of company_identification' do
-        get application_mode_candidate_market_application_path(market_application.identifier)
+      it 'rejects groupement mode with a 422' do
+        patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'groupement' }
+
+        expect(response).to have_http_status(:unprocessable_content)
+        expect(market_application.reload.application_mode).to be_nil
+      end
+
+      it 'renders the already-mandataire error message and re-disables groupement/mixte' do
+        patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'groupement' }
+
+        rendered = Nokogiri::HTML(response.body)
+        expect(rendered.text).to include(I18n.t('candidate.validations.already_mandataire'))
+        expect(rendered.text).to include(I18n.t('candidate.application_modes.already_mandataire_box.title'))
+
+        expect(rendered.at_css('#application_mode_groupement')['disabled']).to eq('disabled')
+        expect(rendered.at_css('#application_mode_mixte')['disabled']).to eq('disabled')
+      end
+
+      it 'still allows solo mode' do
+        patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'solo' }
 
         expect(response).to redirect_to(
-          grouping_legal_type_candidate_market_application_path(market_application.identifier)
+          company_identification_candidate_market_application_path(market_application.identifier)
         )
       end
     end
 
-    context 'when the mode is groupement and the legal type is already chosen' do
+    context 'when the mode is already chosen' do
       before do
         market_application.update!(application_mode: :groupement)
         create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: :conjoint)
       end
 
-      it 'redirects to company_identification' do
-        get application_mode_candidate_market_application_path(market_application.identifier)
+      it 'ignores the resubmitted mode and redirects to the current step, without changing application_mode' do
+        expect do
+          patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'solo' }
+        end.not_to change { market_application.reload.application_mode }
 
         expect(response).to redirect_to(
           company_identification_candidate_market_application_path(market_application.identifier)
         )
       end
+
+      it 'does not orphan the existing grouping' do
+        expect do
+          patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'solo' }
+        end.not_to change(Grouping, :count)
+      end
     end
+  end
 
-    context 'when readonly is requested and the mode is already chosen' do
+  describe 'readonly navigation (application_mode already chosen)' do
+    context 'when the mode is groupement and no co-traitant has been added yet' do
       before do
         market_application.update!(application_mode: :groupement)
-        create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: :conjoint)
+        create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: nil)
       end
 
-      it 'renders the screen instead of redirecting' do
-        get application_mode_candidate_market_application_path(market_application.identifier, readonly: true)
+      it 'renders the screen in readonly instead of redirecting' do
+        get wizard_step_path(market_application, :application_mode), params: { readonly: true }
 
         expect(response).to have_http_status(:ok)
       end
 
       it 'disables the fieldset' do
-        get application_mode_candidate_market_application_path(market_application.identifier, readonly: true)
+        get wizard_step_path(market_application, :application_mode), params: { readonly: true }
 
         rendered = Nokogiri::HTML(response.body)
         expect(rendered.at_css('fieldset')['disabled']).to eq('disabled')
       end
 
       it 'checks the already chosen mode' do
-        get application_mode_candidate_market_application_path(market_application.identifier, readonly: true)
+        get wizard_step_path(market_application, :application_mode), params: { readonly: true }
 
         rendered = Nokogiri::HTML(response.body)
         expect(rendered.at_css('#application_mode_groupement')['checked']).to eq('checked')
       end
 
       it 'does not show the already-mandataire-elsewhere callout for its own grouping' do
-        get application_mode_candidate_market_application_path(market_application.identifier, readonly: true)
+        get wizard_step_path(market_application, :application_mode), params: { readonly: true }
 
         rendered = Nokogiri::HTML(response.body)
         expect(rendered.text).not_to include(I18n.t('candidate.application_modes.already_mandataire_box.title'))
       end
 
-      it 'points the continue link to company_identification since the legal type is already chosen' do
-        get application_mode_candidate_market_application_path(market_application.identifier, readonly: true)
+      it 'points the continue link to grouping_legal_type, not skipping it' do
+        get wizard_step_path(market_application, :application_mode), params: { readonly: true }
 
         rendered = Nokogiri::HTML(response.body)
         link = rendered.at_css('a.fr-icon-arrow-right-line')
-        expect(link['href']).to eq(company_identification_candidate_market_application_path(market_application.identifier))
+        expect(link['href']).to eq(wizard_step_path(market_application, :grouping_legal_type))
       end
     end
 
-    context 'when readonly is requested and the legal type is not chosen yet' do
+    context 'regression: revisiting application_mode while the legal type is not chosen yet must not skip it' do
       before do
         market_application.update!(application_mode: :groupement)
         create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: nil)
       end
 
-      it 'points the continue link to grouping_legal_type' do
-        get application_mode_candidate_market_application_path(market_application.identifier, readonly: true)
+      it 'still points the continue link to grouping_legal_type' do
+        get wizard_step_path(market_application, :application_mode), params: { readonly: true }
 
         rendered = Nokogiri::HTML(response.body)
         link = rendered.at_css('a.fr-icon-arrow-right-line')
-        expect(link['href']).to eq(grouping_legal_type_candidate_market_application_path(market_application.identifier))
+        expect(link['href']).to eq(wizard_step_path(market_application, :grouping_legal_type))
       end
-    end
 
-    context 'when the application is already completed' do
-      let(:market_application) do
-        create(:market_application, :completed, public_market:, siret: '73282932000074')
-      end
-
-      it 'redirects to sync status instead of showing the choice screen' do
-        get application_mode_candidate_market_application_path(market_application.identifier)
+      it 'allows navigating to grouping_legal_type to choose the type' do
+        get wizard_step_path(market_application, :grouping_legal_type)
 
-        expect(response).to redirect_to(candidate_sync_status_path(market_application.identifier))
+        rendered = Nokogiri::HTML(response.body)
+        expect(rendered.at_css('fieldset')).to be_present
       end
     end
-  end
-
-  describe 'PATCH /candidate/market_applications/:identifier/application_mode' do
-    it 'sets the mode to solo and redirects to company_identification' do
-      patch application_mode_candidate_market_application_path(market_application.identifier),
-        params: { application_mode: 'solo' }
-
-      expect(market_application.reload).to be_solo
-      expect(response).to redirect_to(
-        company_identification_candidate_market_application_path(market_application.identifier)
-      )
-    end
-
-    it 'creates a grouping when choosing groupement' do
-      expect do
-        patch application_mode_candidate_market_application_path(market_application.identifier),
-          params: { application_mode: 'groupement' }
-      end.to change(Grouping, :count).by(1)
-
-      expect(market_application.reload).to be_groupement
-      expect(response).to redirect_to(
-        grouping_legal_type_candidate_market_application_path(market_application.identifier)
-      )
-    end
-
-    it 'does not require re-authentication when reaching the next step after choosing groupement' do
-      patch application_mode_candidate_market_application_path(market_application.identifier),
-        params: { application_mode: 'groupement' }
-
-      get company_identification_candidate_market_application_path(market_application.identifier)
-
-      expect(response).to have_http_status(:ok)
-      expect(response.body).not_to include(I18n.t('candidate.sessions.new.siret_label'))
-    end
-
-    it 'creates two applications when choosing mixte and redirects to grouping_legal_type' do
-      expect do
-        patch application_mode_candidate_market_application_path(market_application.identifier),
-          params: { application_mode: 'mixte' }
-      end.to change(MarketApplication, :count).by(1)
-
-      groupement_application = MarketApplication.find_by(public_market:, siret: market_application.siret,
-        application_mode: :groupement)
-      expect(response).to redirect_to(
-        grouping_legal_type_candidate_market_application_path(groupement_application.identifier)
-      )
-    end
 
-    it 'associates the authenticated user to the groupement counterpart created in mixte mode' do
-      patch application_mode_candidate_market_application_path(market_application.identifier),
-        params: { application_mode: 'mixte' }
+    context 'when the mode is not groupement/mixte (solo)' do
+      before { market_application.update!(application_mode: :solo) }
 
-      groupement_application = MarketApplication.where(public_market:, siret: market_application.siret,
-        application_mode: :groupement).sole
+      it 'points the continue link to company_identification' do
+        get wizard_step_path(market_application, :application_mode), params: { readonly: true }
 
-      expect(groupement_application.user).to eq(user)
+        rendered = Nokogiri::HTML(response.body)
+        link = rendered.at_css('a.fr-icon-arrow-right-line')
+        expect(link['href']).to eq(company_identification_candidate_market_application_path(market_application.identifier))
+      end
     end
 
-    it 'does not require re-authentication when reaching the next step after choosing mixte' do
-      patch application_mode_candidate_market_application_path(market_application.identifier),
-        params: { application_mode: 'mixte' }
-
-      groupement_application = MarketApplication.where(public_market:, siret: market_application.siret,
-        application_mode: :groupement).sole
-
-      get company_identification_candidate_market_application_path(groupement_application.identifier)
-
-      expect(response).to have_http_status(:ok)
-      expect(response.body).not_to include(I18n.t('candidate.sessions.new.siret_label'))
-    end
+    context 'for the solo side of a mixte application with an incomplete groupement counterpart' do
+      let!(:groupement_application) do
+        create(:market_application, public_market:, siret: market_application.siret, application_mode: :groupement, user:)
+      end
 
-    context 'when the SIRET is already mandataire of a grouping on this market' do
       before do
-        other_application = create(:market_application, public_market:, siret: market_application.siret,
-          application_mode: :groupement)
-        create(:grouping, public_market:, mandataire_market_application: other_application)
+        market_application.update!(application_mode: :solo)
+        create(:grouping, public_market:, mandataire_market_application: groupement_application, legal_type: nil)
       end
 
-      it 'rejects groupement mode with a 422' do
-        patch application_mode_candidate_market_application_path(market_application.identifier),
-          params: { application_mode: 'groupement' }
+      it 'points the continue link to the groupement counterpart grouping_legal_type step' do
+        get wizard_step_path(market_application, :application_mode), params: { readonly: true }
 
-        expect(response).to have_http_status(:unprocessable_content)
-        expect(market_application.reload.application_mode).to be_nil
+        rendered = Nokogiri::HTML(response.body)
+        link = rendered.at_css('a.fr-icon-arrow-right-line')
+        expect(link['href']).to eq(wizard_step_path(groupement_application, :grouping_legal_type))
       end
+    end
 
-      it 'renders the already-mandataire error message and re-disables groupement/mixte' do
-        patch application_mode_candidate_market_application_path(market_application.identifier),
-          params: { application_mode: 'groupement' }
-
-        rendered = Nokogiri::HTML(response.body)
-        expect(rendered.text).to include(I18n.t('candidate.validations.already_mandataire'))
-        expect(rendered.text).to include(I18n.t('candidate.application_modes.already_mandataire_box.title'))
+    context 'for the solo side of a mixte application with a completed groupement counterpart' do
+      let!(:groupement_application) do
+        create(:market_application, public_market:, siret: market_application.siret, application_mode: :groupement, user:)
+      end
 
-        expect(rendered.at_css('#application_mode_groupement')['disabled']).to eq('disabled')
-        expect(rendered.at_css('#application_mode_mixte')['disabled']).to eq('disabled')
+      before do
+        market_application.update!(application_mode: :solo)
+        grouping = create(:grouping, public_market:, mandataire_market_application: groupement_application, legal_type: :conjoint)
+        create(:grouping_member, :co_traitant, grouping:, invitation_token_created_at: Time.current)
       end
 
-      it 'still allows solo mode' do
-        patch application_mode_candidate_market_application_path(market_application.identifier),
-          params: { application_mode: 'solo' }
+      it 'points the continue link to its own company_identification step' do
+        get wizard_step_path(market_application, :application_mode), params: { readonly: true }
 
-        expect(response).to redirect_to(
-          company_identification_candidate_market_application_path(market_application.identifier)
-        )
+        rendered = Nokogiri::HTML(response.body)
+        link = rendered.at_css('a.fr-icon-arrow-right-line')
+        expect(link['href']).to eq(company_identification_candidate_market_application_path(market_application.identifier))
       end
     end
   end
diff --git a/spec/requests/candidate/grouping_legal_types_spec.rb b/spec/requests/candidate/grouping_legal_types_spec.rb
index 58a088d1b..3bd22e37f 100644
--- a/spec/requests/candidate/grouping_legal_types_spec.rb
+++ b/spec/requests/candidate/grouping_legal_types_spec.rb
@@ -5,9 +5,7 @@
 RSpec.describe 'Candidate::GroupingLegalTypes', type: :request do
   let(:editor) { create(:editor) }
   let(:public_market) { create(:public_market, :completed, editor:) }
-  let(:market_application) do
-    create(:market_application, public_market:, siret: '73282932000074', application_mode: :groupement)
-  end
+  let(:market_application) { create(:market_application, public_market:, siret: '73282932000074') }
   let(:user) { create(:user) }
 
   before do
@@ -16,55 +14,56 @@
     sign_in_as_candidate(user, market_application)
   end
 
-  describe 'GET /candidate/market_applications/:identifier/grouping_legal_type' do
+  def wizard_step_path(market_application, step)
+    case step
+    when :application_mode
+      application_mode_candidate_market_application_path(market_application.identifier)
+    when :grouping_legal_type
+      grouping_legal_type_candidate_market_application_path(market_application.identifier)
+    end
+  end
+
+  describe 'GET .../grouping_legal_type' do
     context 'when the market_application is mandataire of a grouping' do
-      before { create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: nil) }
+      before do
+        market_application.update!(application_mode: :groupement)
+        create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: nil)
+      end
 
       it 'renders successfully' do
-        get grouping_legal_type_candidate_market_application_path(market_application.identifier)
+        get wizard_step_path(market_application, :grouping_legal_type)
         expect(response).to have_http_status(:ok)
         expect(response.body).to include(I18n.t('candidate.grouping_legal_types.title'))
       end
-
-      it 'returns 404 when the feature flag is disabled' do
-        allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(false)
-
-        get grouping_legal_type_candidate_market_application_path(market_application.identifier)
-        expect(response).to have_http_status(:not_found)
-      end
     end
 
-    context 'when the market_application is not mandataire of any grouping' do
+    context 'when the market_application is not mandataire of any grouping (mode not chosen)' do
       it 'redirects to application_mode' do
-        get grouping_legal_type_candidate_market_application_path(market_application.identifier)
+        get wizard_step_path(market_application, :grouping_legal_type)
 
-        expect(response).to redirect_to(
-          application_mode_candidate_market_application_path(market_application.identifier)
-        )
+        expect(response).to redirect_to(wizard_step_path(market_application, :application_mode))
       end
     end
 
     context 'when the application mode is solo' do
-      let(:market_application) do
-        create(:market_application, public_market:, siret: '73282932000074', application_mode: :solo)
-      end
+      before { market_application.update!(application_mode: :solo) }
 
       it 'redirects to application_mode' do
-        get grouping_legal_type_candidate_market_application_path(market_application.identifier)
+        get wizard_step_path(market_application, :grouping_legal_type)
 
-        expect(response).to redirect_to(
-          application_mode_candidate_market_application_path(market_application.identifier)
-        )
+        expect(response).to redirect_to(wizard_step_path(market_application, :application_mode))
       end
     end
   end
 
-  describe 'PATCH /candidate/market_applications/:identifier/grouping_legal_type' do
-    before { create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: nil) }
+  describe 'PATCH .../grouping_legal_type' do
+    before do
+      market_application.update!(application_mode: :groupement)
+      create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: nil)
+    end
 
     it 'sets the legal_type and redirects to company_identification' do
-      patch grouping_legal_type_candidate_market_application_path(market_application.identifier),
-        params: { legal_type: 'conjoint_mandataire_solidaire' }
+      patch wizard_step_path(market_application, :grouping_legal_type), params: { legal_type: 'conjoint_mandataire_solidaire' }
 
       expect(Grouping.joins(:mandataire_market_application).find_by(market_applications: { id: market_application.id }).legal_type)
         .to eq('conjoint_mandataire_solidaire')
@@ -74,8 +73,7 @@
     end
 
     it 'rejects an invalid legal_type with a 422' do
-      patch grouping_legal_type_candidate_market_application_path(market_application.identifier),
-        params: { legal_type: 'invalid_garbage' }
+      patch wizard_step_path(market_application, :grouping_legal_type), params: { legal_type: 'invalid_garbage' }
 
       expect(response).to have_http_status(:unprocessable_content)
       rendered = Nokogiri::HTML(response.body)
diff --git a/spec/requests/candidate/sessions_spec.rb b/spec/requests/candidate/sessions_spec.rb
index 19384d07a..2197e6351 100644
--- a/spec/requests/candidate/sessions_spec.rb
+++ b/spec/requests/candidate/sessions_spec.rb
@@ -262,6 +262,38 @@
           step_candidate_market_application_path(market_application.identifier, :company_identification)
         )
       end
+
+      context 'when the application is the solo side of a mixte candidacy without a user yet' do
+        let!(:groupement_application) do
+          create(:market_application, public_market: market_application.public_market, siret: market_application.siret,
+            application_mode: :groupement)
+        end
+
+        before { market_application.update!(application_mode: :solo) }
+
+        it 'also links the user to the groupement counterpart' do
+          expect do
+            get verify_candidate_sessions_path,
+              params: { token:, market_application_id: market_application.identifier }
+          end.to change { groupement_application.reload.user_id }.from(nil).to(user.id)
+        end
+      end
+
+      context 'when the application is the groupement side of a mixte candidacy without a user yet' do
+        let!(:solo_application) do
+          create(:market_application, public_market: market_application.public_market, siret: market_application.siret,
+            application_mode: :solo)
+        end
+
+        before { market_application.update!(application_mode: :groupement) }
+
+        it 'also links the user to the solo counterpart' do
+          expect do
+            get verify_candidate_sessions_path,
+              params: { token:, market_application_id: market_application.identifier }
+          end.to change { solo_application.reload.user_id }.from(nil).to(user.id)
+        end
+      end
     end
 
     context 'when market has lots and no lots are selected' do